@elyx-code/project-logic-tree 0.0.6113 → 0.0.6115

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

@@ -1,6 +1,6 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IActionDescriptor, IActionDescriptorGenerationTarget, IActionDescriptorReference, IActionDescriptorShallowTransfer, IActionDescriptorTransfer, IFunctionDeclarationTransfer, ActionDescriptorTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, UserManagedEntityStateFunctionality } from '../base';
+import { BaseState, ChildEntityState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { ProjectState } from '../project/project';
 import { DataTypeState } from '../data-type';
 import { ValueDescriptorState } from '../value-descriptor';
@@ -44,6 +44,7 @@ export declare class ActionDescriptorState implements IActionDescriptor, UserMan
     initialized: boolean;
     autoexecutable: boolean;
     constructor(initialFunctionData: IActionDescriptor | IActionDescriptorTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];
@@ -69,16 +70,18 @@ export declare class ActionDescriptorState implements IActionDescriptor, UserMan
         errors: EntityGenerationError[];
         modifiedData: Partial<IActionDescriptorGenerationTarget>;
     };
+    hydrateAncestors(): IChangeSet<ActionDescriptorState>;
+    afterAllChildrenInitialized(): IChangeSet<ActionDescriptorState>;
     addSelfToProject(): IChangeSet<ActionDescriptorState>;
     setParent(parent: CustomEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState): ActionDescriptorState;
     initChildren(): ActionDescriptorState;
     subscribe(): ActionDescriptorState;
     unsubscribe(): ActionDescriptorState;
     sync(data: Partial<IActionDescriptor>): ActionDescriptorState;
-    load(): Promise<ActionDescriptorState>;
-    create(): Promise<ActionDescriptorState>;
-    update(_: Partial<ActionDescriptorTypesUnion>): Promise<ActionDescriptorState>;
-    delete(): Promise<ActionDescriptorState>;
+    load(_?: IEntityPersistanceOptions): Promise<ActionDescriptorState>;
+    create(_?: IEntityPersistanceOptions): Promise<ActionDescriptorState>;
+    update(_?: IEntityPersistanceOptions): Promise<ActionDescriptorState>;
+    delete(_?: IEntityPersistanceOptions): Promise<ActionDescriptorState>;
     remove({ ignoreUpstream: _, seenEntities, }?: {
         ignoreUpstream: boolean;
         seenEntities: Set<string>;
@@ -92,14 +95,15 @@ export declare class ActionDescriptorState implements IActionDescriptor, UserMan
         affected: EntityState[];
         self: ActionDescriptorState;
     };
-    toFlat(seenEntities?: Set<string>): EntityState[];
-    toFlatIds(seenEntities?: Set<string>): EntityId[];
-    toJSON(): IActionDescriptorTransfer;
-    toReference(): IActionDescriptorReference;
-    toShallowJSON(): IActionDescriptorShallowTransfer;
-    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toJSON(seenEntities?: Set<EntityId>): IActionDescriptorTransfer | IActionDescriptorReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IActionDescriptorTransfer | IActionDescriptorReference;
+    toReference(options?: IEntityRecursionOptions): IActionDescriptorReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IActionDescriptorShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
     toGenerationTarget(): IActionDescriptorGenerationTarget;
-    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
     implementAsFunctionDeclaration(newEntityId: string): IFunctionDeclarationTransfer;
     implementAsLoop(parent?: EntityWithLogicScopeState): LoopState;
     implementAsOperation(parent?: EntityWithLogicScopeState, newId?: string): OperationState;
@@ -114,8 +118,8 @@ export declare class ActionDescriptorState implements IActionDescriptor, UserMan
     getShallowErrors(): EntityError[];
     clone(parent?: CustomEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState | null, newId?: string | null, subscribe?: boolean): ActionDescriptorState;
     addInput(argument: ValueDescriptorState): ActionDescriptorState;
-    removeFixedArgument(argument: ValueDescriptorState): ActionDescriptorState;
+    removeInput(argument: ValueDescriptorState): ActionDescriptorState;
     addOutput(output: ValueDescriptorState): ActionDescriptorState;
-    removeFixedReturn(output: ValueDescriptorState): ActionDescriptorState;
+    removeOutput(output: ValueDescriptorState): ActionDescriptorState;
 }
 export type ActionDescriptorPayloadUnion = ActionDescriptorState | ActionDescriptorTypesUnion;

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

@@ -1,6 +1,6 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IArgumentDeclaration, IArgumentDeclarationGenerationTarget, IArgumentDeclarationReference, IArgumentDeclarationShallowTransfer, IArgumentDeclarationTransfer, ArgumentDeclarationTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, EntityWithValueClass, UserManagedEntityStateFunctionality, ValueWritingEntityClass } from '../base';
+import { BaseState, ChildEntityState, EntityWithValueClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, ValueWritingEntityClass, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { EntityState, EntryPointEntityState, IChangeSet, ValueReadingEntityState } from '../types';
 import { DataTypeState } from '../data-type';
 import { ProjectState } from '../project/project';
@@ -27,6 +27,7 @@ export declare class ArgumentDeclarationState implements IArgumentDeclaration, U
     initialized: boolean;
     suggestion: boolean;
     constructor(initialArgumentDeclarationData: IArgumentDeclaration | IArgumentDeclarationTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];
@@ -49,6 +50,8 @@ export declare class ArgumentDeclarationState implements IArgumentDeclaration, U
         errors: EntityGenerationError[];
         modifiedData: Partial<IArgumentDeclarationGenerationTarget>;
     };
+    hydrateAncestors(): IChangeSet<ArgumentDeclarationState>;
+    afterAllChildrenInitialized(): IChangeSet<ArgumentDeclarationState>;
     addSelfToProject(): IChangeSet<ArgumentDeclarationState>;
     addValueReader(entity: ValueReadingEntityState): ArgumentDeclarationState;
     removeValueReader(valueReader: ValueReadingEntityState): ArgumentDeclarationState;
@@ -58,10 +61,10 @@ export declare class ArgumentDeclarationState implements IArgumentDeclaration, U
     subscribe(): ArgumentDeclarationState;
     unsubscribe(): ArgumentDeclarationState;
     sync(data: Partial<IArgumentDeclaration>): ArgumentDeclarationState;
-    load(): Promise<ArgumentDeclarationState>;
-    create(): Promise<ArgumentDeclarationState>;
-    update(_: Partial<ArgumentDeclarationTypesUnion>): Promise<ArgumentDeclarationState>;
-    delete(): Promise<ArgumentDeclarationState>;
+    load(_?: IEntityPersistanceOptions): Promise<ArgumentDeclarationState>;
+    create(_?: IEntityPersistanceOptions): Promise<ArgumentDeclarationState>;
+    update(_?: IEntityPersistanceOptions): Promise<ArgumentDeclarationState>;
+    delete(_?: IEntityPersistanceOptions): Promise<ArgumentDeclarationState>;
     remove({ ignoreUpstream, seenEntities, }?: {
         ignoreUpstream: boolean;
         seenEntities: Set<string>;
@@ -75,14 +78,15 @@ export declare class ArgumentDeclarationState implements IArgumentDeclaration, U
         affected: EntityState[];
         self: ArgumentDeclarationState;
     };
-    toFlat(seenEntities?: Set<string>): EntityState[];
-    toFlatIds(seenEntities?: Set<string>): EntityId[];
-    toJSON(): IArgumentDeclarationTransfer;
-    toReference(): IArgumentDeclarationReference;
-    toShallowJSON(): IArgumentDeclarationShallowTransfer;
-    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toJSON(seenEntities?: Set<EntityId>): IArgumentDeclarationTransfer | IArgumentDeclarationReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IArgumentDeclarationTransfer | IArgumentDeclarationReference;
+    toReference(options?: IEntityRecursionOptions): IArgumentDeclarationReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IArgumentDeclarationShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
     toGenerationTarget(): IArgumentDeclarationGenerationTarget;
-    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
     clearErrors(): ArgumentDeclarationState;
     validate(): {
         success: boolean;

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

@@ -428,11 +428,11 @@ export declare function getArgumentDeclarationSchema(): z.ZodObject<z.objectUtil
         entityId: string;
     };
     version: number;
+    x: number;
+    y: number;
     dataType: Record<string, any> | {
         type: EntityType.DataType;
     } | null;
-    x: number;
-    y: number;
     writesValues: (Record<string, any> | {
         type: EntityType.InputMap;
     } | {
@@ -472,11 +472,11 @@ export declare function getArgumentDeclarationSchema(): z.ZodObject<z.objectUtil
         entityId: string;
     };
     version: number;
+    x: number;
+    y: number;
     dataType: Record<string, any> | {
         type: EntityType.DataType;
     } | null;
-    x: number;
-    y: number;
     writesValues: (Record<string, any> | {
         type: EntityType.InputMap;
     } | {

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

@@ -1,10 +1,19 @@
-import { EntityId, EntityType, EntityVersion, IGenericBase, Element, ElementTransfer, IGenericReference, ElementShallowTransfer, ElementGenerationTarget, ElementTypesUnion } from '../../definitions';
+import { EntityId, EntityType, EntityVersion, IGenericBase, Element, ElementTransfer, IGenericReference, ElementShallowTransfer, ElementGenerationTarget, Reference } from '../../definitions';
 import { ZodError } from 'zod';
 import { CallableEntityState, CallerEntityState, CanvasEntityState, EntityState, IChangeSet, InputMapState, ValueReadingEntityState, ValueWritingEntityState } from '.';
 import { ProjectState } from './project/project';
 import { EntityError } from './error';
 import { LiteralValueState } from './literal-value';
 
+export interface IEntityRecursionOptions {
+    seenEntityMaps?: Map<EntityId, EntityId>;
+    seenEntities?: Set<EntityId>;
+}
+export declare const ENTITY_RECUSION_OPTIONS_DEFAULTS: IEntityRecursionOptions;
+export interface IEntityJSONCloneOptions extends IEntityRecursionOptions {
+    newId?: EntityId | null;
+    uuidStrategy?: 'uuid' | 'semantic';
+}
 export declare abstract class SharedStateFunctionality {
     initialData: Element | ElementTransfer;
     abstract errors: EntityError[];
@@ -12,11 +21,11 @@ export declare abstract class SharedStateFunctionality {
     abstract subscribe(): SharedStateFunctionality;
     abstract unsubscribe(): SharedStateFunctionality;
     abstract load(): Promise<SharedStateFunctionality>;
-    abstract toJSON(): ElementTransfer;
-    abstract toReference(): IGenericReference;
+    abstract toJSON(seenEntities?: Set<string>): ElementTransfer | Reference;
+    abstract toReference(options?: IEntityRecursionOptions): IGenericReference;
     abstract toFlat(seenEntities?: Set<string>): EntityState[];
     abstract toFlatIds(seenEntities?: Set<string>): EntityId[];
-    abstract toShallowJSON(): ElementShallowTransfer;
+    abstract toShallowJSON(options?: IEntityRecursionOptions): ElementShallowTransfer;
     abstract toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
     abstract toGenerationTarget(): ElementGenerationTarget;
     abstract toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
@@ -26,16 +35,31 @@ export declare abstract class SharedStateFunctionality {
         data: ElementTransfer | null;
     };
     abstract clearErrors(): SharedStateFunctionality;
-    abstract clone(parent?: EntityState | null, newId?: string | null, subscribe?: boolean): SharedStateFunctionality;
     abstract getErrors(): EntityError[];
     abstract getShallowErrors(): EntityError[];
 }
+export interface IEntityPersistanceOptions {
+    cascade?: boolean;
+}
+export declare const ENTITY_PERSISTANCE_OPTIONS_DEFAULTS: IEntityPersistanceOptions;
+export interface IReadOnlyEntityPersistanceRepository {
+    load(entityId: EntityId): Promise<ElementShallowTransfer | null>;
+}
+export interface IEditableEntityPersistanceRepository extends IReadOnlyEntityPersistanceRepository {
+    create(entity: ElementShallowTransfer): Promise<ElementShallowTransfer>;
+    update(entity: ElementShallowTransfer): Promise<ElementShallowTransfer>;
+    delete(entityId: EntityId): Promise<void>;
+}
+export declare const READ_ONLY_ENTITY_PERSISTANCE_REPOSITORY: IReadOnlyEntityPersistanceRepository;
+export declare const EDITABLE_PERSISTANCE_REPOSITORY_DEFAULTS: IEditableEntityPersistanceRepository;
 export declare abstract class UserManagedEntityStateFunctionality {
+    abstract hydrateAncestors(): IChangeSet<UserManagedEntityStateFunctionality>;
     abstract addSelfToProject(): IChangeSet<UserManagedEntityStateFunctionality>;
+    abstract afterAllChildrenInitialized(): IChangeSet<UserManagedEntityStateFunctionality>;
     abstract sync(data: Partial<IGenericBase>): SharedStateFunctionality;
-    abstract create(): Promise<SharedStateFunctionality>;
-    abstract update(data: Partial<ElementTypesUnion>): Promise<SharedStateFunctionality>;
-    abstract delete(): Promise<SharedStateFunctionality>;
+    abstract create(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
+    abstract update(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
+    abstract delete(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
     abstract remove(options: {
         ignoreUpstream: boolean;
         seenEntities: Set<string>;
@@ -49,6 +73,8 @@ export declare abstract class UserManagedEntityStateFunctionality {
         affected: EntityState[];
         self: EntityState;
     };
+    abstract toJSONClone(options?: IEntityJSONCloneOptions): ElementTransfer | Reference;
+    abstract clone(parent?: EntityState | null, newId?: string | null, subscribe?: boolean): SharedStateFunctionality;
 }
 export declare abstract class BaseState extends SharedStateFunctionality implements IGenericBase {
     abstract id: EntityId;

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

@@ -1,7 +1,6 @@
 import { BreakStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IBreakStatement, IBreakStatementGenerationTarget, IBreakStatementReference, IBreakStatementShallowTransfer, IBreakStatementTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, UserManagedEntityStateFunctionality } from '../base';
-import { FunctionDeclarationState } from '../function-declaration';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { ReturnDeclarationState } from '../return-declaration';
 import { CallerEntityState, EntityState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
 import { ProjectState } from '../project/project';
@@ -26,6 +25,7 @@ export declare class BreakStatementState implements IBreakStatement, UserManaged
     initialized: boolean;
     suggestion: boolean;
     constructor(initialBreakStatementData: IBreakStatement | IBreakStatementTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];
@@ -48,6 +48,8 @@ export declare class BreakStatementState implements IBreakStatement, UserManaged
         errors: EntityGenerationError[];
         modifiedData: Partial<IBreakStatementGenerationTarget>;
     };
+    hydrateAncestors(): IChangeSet<BreakStatementState>;
+    afterAllChildrenInitialized(): IChangeSet<BreakStatementState>;
     addSelfToProject(): IChangeSet<BreakStatementState>;
     get calledBy(): CallerEntityState[];
     addSuccessCaller(caller: PassThroughCallableEntityState): BreakStatementState;
@@ -61,10 +63,10 @@ export declare class BreakStatementState implements IBreakStatement, UserManaged
     subscribe(): BreakStatementState;
     unsubscribe(): BreakStatementState;
     sync(data: Partial<IBreakStatement>): BreakStatementState;
-    load(): Promise<BreakStatementState>;
-    create(): Promise<BreakStatementState>;
-    update(_: Partial<BreakStatementTypesUnion>): Promise<BreakStatementState>;
-    delete(): Promise<BreakStatementState>;
+    load(_?: IEntityPersistanceOptions): Promise<BreakStatementState>;
+    create(_?: IEntityPersistanceOptions): Promise<BreakStatementState>;
+    update(_?: IEntityPersistanceOptions): Promise<BreakStatementState>;
+    delete(_?: IEntityPersistanceOptions): Promise<BreakStatementState>;
     remove({ ignoreUpstream, seenEntities, }?: {
         ignoreUpstream: boolean;
         seenEntities: Set<string>;
@@ -78,14 +80,15 @@ export declare class BreakStatementState implements IBreakStatement, UserManaged
         affected: EntityState[];
         self: EntityState;
     };
-    toFlat(seenEntities?: Set<string>): EntityState[];
-    toFlatIds(seenEntities?: Set<string>): EntityId[];
-    toJSON(): IBreakStatementTransfer;
-    toReference(): IBreakStatementReference;
-    toShallowJSON(): IBreakStatementShallowTransfer;
-    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toJSON(seenEntities?: Set<EntityId>): IBreakStatementTransfer | IBreakStatementReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IBreakStatementTransfer | IBreakStatementReference;
+    toReference(options?: IEntityRecursionOptions): IBreakStatementReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IBreakStatementShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
     toGenerationTarget(): IBreakStatementGenerationTarget;
-    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
     clearErrors(): BreakStatementState;
     validate(): {
         success: boolean;
@@ -94,6 +97,6 @@ export declare class BreakStatementState implements IBreakStatement, UserManaged
     };
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
-    clone(_?: FunctionDeclarationState): BreakStatementState;
+    clone(parent?: LoopState | null, newId?: string | null, subscribe?: boolean): BreakStatementState;
 }
 export type BreakStatementPayloadUnion = BreakStatementState | BreakStatementTypesUnion;

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

@@ -1,6 +1,6 @@
 import { BaseEntityNames, BuiltInBaseEntityTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IBuiltInBaseEntity, IBuiltInBaseEntityGenerationTarget, IBuiltInBaseEntityReference, IBuiltInBaseEntityShallowTransfer, IBuiltInBaseEntityTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState } from '../base';
+import { BaseState, IEntityPersistanceOptions, IEntityRecursionOptions, IReadOnlyEntityPersistanceRepository } from '../base';
 import { PropertyState } from '../property';
 import { ProjectState } from '../project/project';
 import { PrimitiveEntityState } from '../primitive-entity';
@@ -27,6 +27,7 @@ export declare class BuiltInBaseEntityState implements BaseState, IBuiltInBaseEn
     errors: EntityError[];
     project: ProjectState;
     constructor(initialEntityData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer, parentProjectState: ProjectState);
+    static repository: IReadOnlyEntityPersistanceRepository;
     get allBasePropertiesFromExtendedAndImplementedEntities(): PropertyState[];
     get extendedPropertiesFromOriginalParents(): PropertyState[];
     get implementedPropertiesFromOriginalParents(): PropertyState[];
@@ -34,7 +35,7 @@ export declare class BuiltInBaseEntityState implements BaseState, IBuiltInBaseEn
     get ownDeclaredProperties(): PropertyState[];
     subscribe(): BuiltInBaseEntityState;
     unsubscribe(): BuiltInBaseEntityState;
-    load(): Promise<BuiltInBaseEntityState>;
+    load(_?: IEntityPersistanceOptions): Promise<BuiltInBaseEntityState>;
     remove(_?: {
         ignoreUpstream: boolean;
         seenEntities: Set<string>;
@@ -48,14 +49,14 @@ export declare class BuiltInBaseEntityState implements BaseState, IBuiltInBaseEn
         affected: EntityState[];
         self: BuiltInBaseEntityState;
     };
-    toFlat(seenEntities?: Set<string>): EntityState[];
-    toFlatIds(seenEntities?: Set<string>): EntityId[];
-    toJSON(): IBuiltInBaseEntityTransfer;
-    toReference(): IBuiltInBaseEntityReference;
-    toShallowJSON(): IBuiltInBaseEntityShallowTransfer;
-    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toJSON(seenEntities?: Set<EntityId>): IBuiltInBaseEntityTransfer | IBuiltInBaseEntityReference;
+    toReference(_?: IEntityRecursionOptions): IBuiltInBaseEntityReference;
+    toShallowJSON(_?: IEntityRecursionOptions): IBuiltInBaseEntityShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
     toGenerationTarget(): IBuiltInBaseEntityGenerationTarget;
-    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
     clearErrors(): BuiltInBaseEntityState;
     validate(): {
         success: boolean;
@@ -64,7 +65,6 @@ export declare class BuiltInBaseEntityState implements BaseState, IBuiltInBaseEn
     };
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
-    clone(): BuiltInBaseEntityState;
     implement(newEntityName: string, newId?: string): {
         errors: [];
         implemented: CustomEntityState;

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

@@ -39,16 +39,16 @@ export declare function getBuiltInBaseEntityBaseSchema(): z.ZodObject<{
     name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
     description: string | null;
     version: number;
-    abstract: boolean;
     static: boolean;
+    abstract: boolean;
 }, {
     id: string;
     type: EntityType.BuiltInBaseEntity;
     name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
     description: string | null;
     version: number;
-    abstract: boolean;
     static: boolean;
+    abstract: boolean;
 }>;
 export declare function getBuiltInBaseEntityMetaSchema(): z.ZodObject<{
     id: z.ZodString;
@@ -64,16 +64,16 @@ export declare function getBuiltInBaseEntityMetaSchema(): z.ZodObject<{
     name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
     description: string | null;
     version: number;
-    abstract: boolean;
     static: boolean;
+    abstract: boolean;
 }, {
     id: string;
     type: EntityType.BuiltInBaseEntity;
     name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
     description: string | null;
     version: number;
-    abstract: boolean;
     static: boolean;
+    abstract: boolean;
 }>;
 export declare function getBuiltInBaseEntityGenerationTargetSchema(): z.ZodObject<z.objectUtil.extendShape<{
     id: z.ZodString;
@@ -89,16 +89,16 @@ export declare function getBuiltInBaseEntityGenerationTargetSchema(): z.ZodObjec
     name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
     description: string | null;
     version: number;
-    abstract: boolean;
     static: boolean;
+    abstract: boolean;
 }, {
     id: string;
     type: EntityType.BuiltInBaseEntity;
     name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
     description: string | null;
     version: number;
-    abstract: boolean;
     static: boolean;
+    abstract: boolean;
 }>;
 export declare function getBuiltInBaseEntityNestedEntitiesSchema(): z.ZodObject<{
     properties: z.ZodArray<z.ZodUnion<[z.ZodObject<{
@@ -220,8 +220,6 @@ export declare function getBuiltInBaseEntitySchema(): z.ZodObject<z.objectUtil.e
         type: EntityType.BuiltInBaseEntity;
     })[];
     version: number;
-    abstract: boolean;
-    static: boolean;
     methods: (Record<string, any> | {
         type: EntityType.FunctionDeclaration;
     })[];
@@ -231,6 +229,8 @@ export declare function getBuiltInBaseEntitySchema(): z.ZodObject<z.objectUtil.e
     abstractMethods: (Record<string, any> | {
         type: EntityType.ActionDescriptor;
     })[];
+    static: boolean;
+    abstract: boolean;
 }, {
     id: string;
     type: EntityType.BuiltInBaseEntity;
@@ -242,8 +242,6 @@ export declare function getBuiltInBaseEntitySchema(): z.ZodObject<z.objectUtil.e
         type: EntityType.BuiltInBaseEntity;
     })[];
     version: number;
-    abstract: boolean;
-    static: boolean;
     methods: (Record<string, any> | {
         type: EntityType.FunctionDeclaration;
     })[];
@@ -253,4 +251,6 @@ export declare function getBuiltInBaseEntitySchema(): z.ZodObject<z.objectUtil.e
     abstractMethods: (Record<string, any> | {
         type: EntityType.ActionDescriptor;
     })[];
+    static: boolean;
+    abstract: boolean;
 }>;

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

@@ -1,6 +1,6 @@
 import { EntityId, EntityType, EntityVersion, ICondition, IConditionTransfer, IConditionReference, IConditionShallowTransfer, ElementShallowTransfer, IConditionGenerationTarget, ElementGenerationTarget, ConditionTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
 import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
 import { ActionInputMapState } from '../input-map';
 import { ProjectState } from '../project/project';
@@ -27,6 +27,7 @@ export declare class ConditionState implements ICondition, UserManagedEntityStat
     parent: EntityWithLogicScopeState | ProjectState;
     initialized: boolean;
     constructor(initialConditionData: ICondition | IConditionTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];
@@ -49,6 +50,8 @@ export declare class ConditionState implements ICondition, UserManagedEntityStat
         errors: EntityGenerationError[];
         modifiedData: Partial<IConditionGenerationTarget>;
     };
+    hydrateAncestors(): IChangeSet<ConditionState>;
+    afterAllChildrenInitialized(): IChangeSet<ConditionState>;
     addSelfToProject(): IChangeSet<ConditionState>;
     get calledBy(): CallerEntityState[];
     removeInput(input: ActionInputMapState): ConditionState;
@@ -63,14 +66,15 @@ export declare class ConditionState implements ICondition, UserManagedEntityStat
     removeCall(call: CallableEntityState): ConditionState;
     removeCaller(caller: CallerEntityState): ConditionState;
     setParent(parent: EntityWithLogicScopeState | ProjectState): ConditionState;
+    setDeclaration(declaration: ActionDescriptorState): ConditionState;
     initChildren(): ConditionState;
     subscribe(): ConditionState;
     unsubscribe(): ConditionState;
     sync(data: Partial<ICondition>): ConditionState;
-    load(): Promise<ConditionState>;
-    create(): Promise<ConditionState>;
-    update(_: Partial<ConditionTypesUnion>): Promise<ConditionState>;
-    delete(): Promise<ConditionState>;
+    load(_?: IEntityPersistanceOptions): Promise<ConditionState>;
+    create(_?: IEntityPersistanceOptions): Promise<ConditionState>;
+    update(_?: IEntityPersistanceOptions): Promise<ConditionState>;
+    delete(_?: IEntityPersistanceOptions): Promise<ConditionState>;
     remove({ ignoreUpstream, seenEntities, }?: {
         ignoreUpstream: boolean;
         seenEntities: Set<string>;
@@ -84,14 +88,15 @@ export declare class ConditionState implements ICondition, UserManagedEntityStat
         affected: EntityState[];
         self: EntityState;
     };
-    toFlat(seenEntities?: Set<string>): EntityState[];
-    toFlatIds(seenEntities?: Set<string>): EntityId[];
-    toJSON(): IConditionTransfer;
-    toReference(): IConditionReference;
-    toShallowJSON(): IConditionShallowTransfer;
-    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toJSON(seenEntities?: Set<EntityId>): IConditionTransfer | IConditionReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IConditionTransfer | IConditionReference;
+    toReference(options?: IEntityRecursionOptions): IConditionReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IConditionShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
     toGenerationTarget(): IConditionGenerationTarget;
-    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
     clearErrors(): ConditionState;
     validate(): {
         success: boolean;
@@ -100,7 +105,7 @@ export declare class ConditionState implements ICondition, UserManagedEntityStat
     };
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
-    clone(_?: EntryPointEntityState): ConditionState;
+    clone(parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): ConditionState;
     removeUnrecognizedInputs(): IChangeSet<ConditionState>;
     syncMissingFixedInputs(): IChangeSet<ConditionState>;
 }

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

@@ -1,7 +1,6 @@
 import { ContinueStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IContinueStatement, IContinueStatementGenerationTarget, IContinueStatementReference, IContinueStatementShallowTransfer, IContinueStatementTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, UserManagedEntityStateFunctionality } from '../base';
-import { FunctionDeclarationState } from '../function-declaration';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
 import { ReturnDeclarationState } from '../return-declaration';
 import { CallerEntityState, EntityState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
 import { ProjectState } from '../project/project';
@@ -26,6 +25,7 @@ export declare class ContinueStatementState implements IContinueStatement, UserM
     initialized: boolean;
     suggestion: boolean;
     constructor(initialContinueStatementData: IContinueStatement | IContinueStatementTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];
@@ -48,6 +48,8 @@ export declare class ContinueStatementState implements IContinueStatement, UserM
         errors: EntityGenerationError[];
         modifiedData: Partial<IContinueStatementGenerationTarget>;
     };
+    hydrateAncestors(): IChangeSet<ContinueStatementState>;
+    afterAllChildrenInitialized(): IChangeSet<ContinueStatementState>;
     addSelfToProject(): IChangeSet<ContinueStatementState>;
     get calledBy(): CallerEntityState[];
     addSuccessCaller(caller: PassThroughCallableEntityState): ContinueStatementState;
@@ -61,10 +63,10 @@ export declare class ContinueStatementState implements IContinueStatement, UserM
     subscribe(): ContinueStatementState;
     unsubscribe(): ContinueStatementState;
     sync(data: Partial<IContinueStatement>): ContinueStatementState;
-    load(): Promise<ContinueStatementState>;
-    create(): Promise<ContinueStatementState>;
-    update(_: Partial<ContinueStatementTypesUnion>): Promise<ContinueStatementState>;
-    delete(): Promise<ContinueStatementState>;
+    load(_?: IEntityPersistanceOptions): Promise<ContinueStatementState>;
+    create(_?: IEntityPersistanceOptions): Promise<ContinueStatementState>;
+    update(_?: IEntityPersistanceOptions): Promise<ContinueStatementState>;
+    delete(_?: IEntityPersistanceOptions): Promise<ContinueStatementState>;
     remove({ ignoreUpstream, seenEntities, }?: {
         ignoreUpstream: boolean;
         seenEntities: Set<string>;
@@ -78,14 +80,15 @@ export declare class ContinueStatementState implements IContinueStatement, UserM
         affected: EntityState[];
         self: EntityState;
     };
-    toFlat(seenEntities?: Set<string>): EntityState[];
-    toFlatIds(seenEntities?: Set<string>): EntityId[];
-    toJSON(): IContinueStatementTransfer;
-    toReference(): IContinueStatementReference;
-    toShallowJSON(): IContinueStatementShallowTransfer;
-    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toJSON(seenEntities?: Set<EntityId>): IContinueStatementTransfer | IContinueStatementReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IContinueStatementTransfer | IContinueStatementReference;
+    toReference(options?: IEntityRecursionOptions): IContinueStatementReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IContinueStatementShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
     toGenerationTarget(): IContinueStatementGenerationTarget;
-    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
     clearErrors(): ContinueStatementState;
     validate(): {
         success: boolean;
@@ -94,6 +97,6 @@ export declare class ContinueStatementState implements IContinueStatement, UserM
     };
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
-    clone(_?: FunctionDeclarationState): ContinueStatementState;
+    clone(parent?: LoopState | null, newId?: string | null, subscribe?: boolean): ContinueStatementState;
 }
 export type ContinueStatementPayloadUnion = ContinueStatementState | ContinueStatementTypesUnion;