@elyx-code/project-logic-tree 0.0.6999 → 0.0.7000

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

@@ -0,0 +1,185 @@
+import { EntityId, EntityType, EntityVersion, IUserManagedGenericBase, Element, ElementTransfer, IGenericReference, ElementShallowTransfer, ElementGenerationTarget, Reference, UserManagedElementTypesUnion, Element_meta, LiteralValueType, UserManagedElementShallowTransfer, IGenericBase } from '../../definitions';
+import { CallableEntityState, CallerEntityState, CanvasEntityState, ChangeSet, EntityState, EntityWithValueState, IChangeSet, InputMapState, OutputMapState, UserManagedEntityState, ValueReadingEntityState, ValueWritingEntityState } from '.';
+import { ProjectState } from './project/project';
+import { EntityError, EntityInstanceErrorCode, SharedEntityErrorCode } from './error';
+import { LiteralValueState } from './literal-value';
+
+export interface IEntityRecursionOptions {
+    seenEntityMaps?: Map<EntityId, EntityId>;
+    seenEntities?: Set<EntityId>;
+    timestamp?: string;
+}
+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[];
+    abstract project: ProjectState;
+    abstract subscribe(): SharedStateFunctionality;
+    abstract unsubscribe(): SharedStateFunctionality;
+    abstract APILoad(): Promise<SharedStateFunctionality>;
+    abstract toJSON(seenEntities?: Set<string>): ElementTransfer | Reference;
+    abstract toMeta(): Element_meta;
+    abstract toReference(options?: IEntityRecursionOptions): IGenericReference;
+    abstract toFlat(seenEntities?: Set<string>): EntityState[];
+    abstract toFlatIds(seenEntities?: Set<string>): EntityId[];
+    abstract toShallowJSON(options?: IEntityRecursionOptions): ElementShallowTransfer;
+    abstract toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    abstract toGenerationTarget(): ElementGenerationTarget;
+    abstract toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    abstract validate(): {
+        success: boolean;
+    };
+    abstract clearErrors(): SharedStateFunctionality;
+    abstract getErrors(): EntityError[];
+    abstract getShallowErrors(): EntityError[];
+}
+export interface IEntityPersistanceOptions {
+    cascade?: boolean;
+}
+export declare const ENTITY_PERSISTANCE_OPTIONS_DEFAULTS: IEntityPersistanceOptions;
+export interface IReadOnlyEntityPersistanceRepository {
+    APILoad<T extends Array<any> = any[]>(entityId: EntityId, ...otherArgs: T): Promise<ElementShallowTransfer | null>;
+}
+export interface IEditableEntityPersistanceRepository extends IReadOnlyEntityPersistanceRepository {
+    APICreate<T extends Array<any> = any[]>(entity: ElementShallowTransfer, ...otherArgs: T): Promise<ElementShallowTransfer>;
+    APIUpdate<T extends Array<any> = any[]>(entity: ElementShallowTransfer, ...otherArgs: T): Promise<ElementShallowTransfer>;
+    APIDelete<T extends Array<any> = any[]>(entity: ElementShallowTransfer, ...otherArgs: T): Promise<ElementShallowTransfer>;
+    APIClone<T extends Array<any> = any[]>(entityId: EntityId, ...otherArgs: T): Promise<void>;
+    APILoadVersion<T extends Array<any> = any[]>(entityId: EntityId, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: T): Promise<ElementShallowTransfer | null>;
+}
+export declare const READ_ONLY_ENTITY_PERSISTANCE_REPOSITORY: IReadOnlyEntityPersistanceRepository;
+export declare const EDITABLE_PERSISTANCE_REPOSITORY_DEFAULTS: IEditableEntityPersistanceRepository;
+export declare abstract class UserManagedEntityStateTemplate {
+    abstract detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    abstract knownVersions: Map<EntityVersion, EntityState> | null;
+    abstract activeVersion: boolean;
+    abstract captureVersion(): UserManagedEntityStateTemplate;
+    abstract increaseVersion(sharedTimestamp: null | string): UserManagedEntityStateTemplate;
+    abstract recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<UserManagedEntityState>;
+    abstract restoreVersion(version: EntityVersion): Promise<IChangeSet<UserManagedEntityState>>;
+    abstract updateWithShallowTransfer(transfer: UserManagedElementShallowTransfer, changeSet: ChangeSet | null): UserManagedEntityState;
+    abstract updateWithGenerationTarget(target: Partial<ElementGenerationTarget>, changeSet: ChangeSet | null): UserManagedEntityState;
+    abstract hydrateAncestors(): IChangeSet<UserManagedEntityState>;
+    abstract addSelfToProject(changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    abstract afterAllChildrenInitialized(changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    abstract metaSync(data: Partial<Element_meta | Element | ElementTransfer | ElementShallowTransfer>, changeSet: ChangeSet | null): SharedStateFunctionality;
+    abstract APICreate(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
+    abstract APIUpdate(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
+    abstract APIDelete(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
+    abstract APIClone(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
+    abstract APILoadVersion(options: IEntityPersistanceOptions, versionIdOrBeforeEqualDate: EntityVersion | Date): Promise<ElementShallowTransfer | null>;
+    abstract remove(options: {
+        ignoreUpstream: boolean;
+    }, changeSet: ChangeSet | null): {
+        updated: EntityState[];
+        removed: EntityState[];
+    };
+    abstract restore(options: {}, changeSet: ChangeSet | null): {
+        updated: EntityState[];
+        self: EntityState;
+    };
+    abstract toJSONClone(options?: IEntityJSONCloneOptions): ElementTransfer | Reference;
+    abstract clone(changeSet: ChangeSet | null, parent?: EntityState | null, newId?: string | null, subscribe?: boolean): SharedStateFunctionality;
+    abstract subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    abstract unsubscribeFromDependencies(): UserManagedEntityState;
+    abstract subscribeToDependencies(): UserManagedEntityState;
+    abstract unsubscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    abstract syncDependents(): IChangeSet<UserManagedEntityState>;
+    abstract onDetachedDependencyRemoved(dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    abstract onDetachedDependencyRestored(dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+}
+export type UserManagedEntityPayloadUnion = UserManagedEntityState | UserManagedElementTypesUnion;
+export declare abstract class BaseState extends SharedStateFunctionality implements IGenericBase {
+    abstract id: EntityId;
+    abstract version: EntityVersion;
+    abstract type: EntityType;
+    abstract previousVersion: string | null;
+    abstract createdAt: string;
+    abstract deleted: boolean;
+    abstract author: string;
+}
+export declare abstract class UserManagedBaseState extends BaseState implements IUserManagedGenericBase {
+    abstract editable: boolean;
+    abstract deletable: boolean;
+}
+export declare abstract class BaseCanvasDraggableState {
+    abstract x: number;
+    abstract y: number;
+}
+export declare abstract class ChildEntityBaseClass {
+    abstract parent: EntityState | null;
+    abstract startedInitialization: boolean;
+    abstract initialized: boolean;
+    abstract setParent(parent: EntityState): ChildEntityBaseClass;
+    abstract initChildren(changeSet: ChangeSet | null): ChildEntityBaseClass;
+    abstract removeFromParent(changeSet: ChangeSet | null): IChangeSet;
+}
+export declare abstract class CallableEntityClass {
+    abstract calledBy: CallerEntityState[];
+    abstract calledBySuccess: CallerEntityState[];
+    abstract calledByError: CallerEntityState[];
+    abstract calledByEntry: CallerEntityState[];
+    abstract addSuccessCaller(caller: PassThroughCallableEntityClass, changeSet: ChangeSet | null, recalculateScope?: boolean): CallableEntityClass;
+    abstract addErrorCaller(caller: PassThroughCallableEntityClass, changeSet: ChangeSet | null, recalculateScope?: boolean): CallableEntityClass;
+    abstract addEntryCaller(caller: EntryPointEntityClass, changeSet: ChangeSet | null, recalculateScope?: boolean): CallableEntityClass;
+    abstract removeCaller(caller: CallerEntityState, changeSet: ChangeSet | null, recalculateScope?: boolean): CallableEntityClass;
+}
+export declare abstract class CallerEntityClass {
+    abstract removeCall(call: CallableEntityState, changeSet: ChangeSet | null, recalculateScope?: boolean): CallerEntityClass;
+}
+export declare abstract class EntryPointEntityClass extends CallerEntityClass {
+    abstract calls: CallableEntityState[];
+    abstract addCall(call: CallableEntityState, changeSet: ChangeSet | null): CallerEntityClass;
+}
+export declare abstract class PassThroughCallableEntityClass extends CallerEntityClass {
+    abstract successCalls: CallableEntityState[];
+    abstract errorCalls: CallableEntityState[];
+    abstract addSuccessCall(call: CallableEntityState, changeSet: ChangeSet | null): CallerEntityClass;
+    abstract addErrorCall(call: CallableEntityState, changeSet: ChangeSet | null): CallerEntityClass;
+    abstract removeInput(input: InputMapState, changeSet: ChangeSet | null): PassThroughCallableEntityClass;
+    abstract addInput(input: InputMapState, changeSet: ChangeSet | null): PassThroughCallableEntityClass;
+    abstract getUnusedInputs(): InputMapState[];
+    abstract getUnusedOutputs(): OutputMapState[];
+    abstract getUsedInputs(): InputMapState[];
+    abstract getUsedOutputs(): OutputMapState[];
+}
+export interface IValueValidationResult<T = LiteralValueType, TCode = SharedEntityErrorCode | EntityInstanceErrorCode> {
+    errors: EntityError<TCode>[];
+    override: T;
+}
+export type ValueValidationCallback<T = LiteralValueType, TCode = SharedEntityErrorCode | EntityInstanceErrorCode> = (self: EntityWithValueState, value: T) => IValueValidationResult<T, TCode>;
+export declare abstract class EntityWithDefaultValueClass {
+    abstract getDefaultValue(): LiteralValueState | null;
+    abstract codeNativeValueValidation: ValueValidationCallback | null;
+}
+export declare abstract class ValueReadingEntityClass {
+    abstract readsValue: ValueWritingEntityState | null;
+    abstract setValueWriter(writer: ValueWritingEntityState, changeSet: ChangeSet | null): ValueReadingEntityState;
+    abstract removeValueWriter(changeSet: ChangeSet | null): ValueReadingEntityState;
+    static initReadsValue(entity: ValueReadingEntityState): ValueWritingEntityState | null;
+}
+export declare abstract class ValueWritingEntityClass {
+    abstract writesValues: ValueReadingEntityState[];
+    abstract addValueReader(reader: ValueReadingEntityState): ValueWritingEntityClass;
+    abstract removeValueReader(reader: ValueReadingEntityState): ValueWritingEntityClass;
+    static initWritesValues(entity: ValueWritingEntityState, childParent: EntityState): ValueReadingEntityState[];
+}
+export declare abstract class EntityWithLogicScopeClass {
+    abstract detachedChildren: CanvasEntityState[];
+    abstract replaceDetachedChild(existingChild: CanvasEntityState, newChild: CanvasEntityState): EntityWithLogicScopeClass;
+    abstract subscribeDetachedChild(child: CanvasEntityState): EntityWithLogicScopeClass;
+    abstract unsubscribeDetachedChild(child: CanvasEntityState): EntityWithLogicScopeClass;
+}

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

@@ -0,0 +1,175 @@
+import { BreakStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IBreakStatement, IBreakStatement_meta, IBreakStatementGenerationTarget, IBreakStatementReference, IBreakStatementShallowTransfer, IBreakStatementTransfer } from '../../../definitions';
+import { BaseCanvasDraggableState, UserManagedBaseState, CallableEntityClass, ChildEntityBaseClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, IEntityJSONCloneOptions, IEntityRecursionOptions, ValueReadingEntityClass, ValueValidationCallback } from '../base';
+import { CallerEntityState, EntityState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState, ValueWritingEntityState } from '../types';
+import { ProjectState } from '../project/project';
+import { LoopState } from '../loop';
+import { EntityError, EntityGenerationError } from '../../state/error';
+import { GenerationExplanationIds } from '../validate';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { DataTypeState } from '../data-type';
+import { LiteralValueState } from '../literal-value';
+import { InputMapState, TerminationInputMapState } from '../input-map';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare enum BreakStatementDependencyField {
+    Parent = "break-statement-parent-field",
+    DataTypeEntity = "break-statement-data-type-entity-field",
+    DataType = "break-statement-data-type-field",
+    ParentDataType = "break-statement-parent-data-type-field",
+    ParentDataTypeEntity = "break-statement-parent-data-type-entity-field"
+}
+export declare class BreakStatementState extends UserManagedVersionedState implements IBreakStatement, UserManagedEntityStateTemplate, UserManagedBaseState, BaseCanvasDraggableState, ValueReadingEntityClass, CallableEntityClass, ChildEntityBaseClass {
+    initialData: IBreakStatement | IBreakStatementTransfer;
+    readonly id: EntityId;
+    x: number;
+    y: number;
+    readonly type: EntityType.BreakStatement;
+    outputs: InputMapState[];
+    readsValue: ValueWritingEntityState | null;
+    dataType: DataTypeState | null;
+    defaultValue: LiteralValueState | null;
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    throws: InputMapState | null;
+    project: ProjectState;
+    errors: EntityError[];
+    parent: LoopState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    suggestion: boolean;
+    readonly _codeNativeValueValidation: ValueValidationCallback | null;
+    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[];
+    static MUTABLE_META_PROPERTIES: string[];
+    static INMUTABLE_META_PROPERTIES: string[];
+    static META_PROPERTIES: string[];
+    static MUTABLE_UPSTREAM_PROPERTIES: string[];
+    static INMUTABLE_UPSTREAM_PROPERTIES: string[];
+    static UPSTREAM_PROPERTIES: string[];
+    static MUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static INMUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static DOWNSTREAM_PROPERTIES: string[];
+    static PROPERTIES: string[];
+    static new(changeSet?: ChangeSet | null): IBreakStatementTransfer;
+    static fromGenerationTarget(data: IBreakStatementGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): BreakStatementState;
+    static validateGenerationTarget(data: IBreakStatementGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IBreakStatementGenerationTarget;
+    };
+    get codeNativeValueValidation(): ValueValidationCallback | null;
+    validateGeneratedUpdate(data: Partial<IBreakStatementGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IBreakStatementGenerationTarget>;
+    };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    unsubscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(changeSet?: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    unsubscribeFromDependencies(): UserManagedEntityState;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
+    captureVersion(): BreakStatementState;
+    snapshot(): BreakStatementState;
+    /**
+     * Given an instance of the same entity class type,
+     * it applies the current entity state to it by copying all of its data and entity references
+     *
+     * @param {BreakStatementState} snapshotInstance
+     * @returns {BreakStatementState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: BreakStatementState): BreakStatementState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<BreakStatementState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<BreakStatementState>>;
+    updateWithShallowTransfer(transfer: IBreakStatementShallowTransfer, changeSet?: ChangeSet | null): BreakStatementState;
+    updateWithGenerationTarget(transfer: Partial<IBreakStatementGenerationTarget>, changeSet?: ChangeSet | null): BreakStatementState;
+    hydrateAncestors(): IChangeSet<BreakStatementState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<BreakStatementState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<BreakStatementState>;
+    get calledBy(): CallerEntityState[];
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): BreakStatementState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): BreakStatementState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): BreakStatementState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): BreakStatementState;
+    setThrows(throws: InputMapState | null, changeSet?: ChangeSet | null): BreakStatementState;
+    addOutput(output: InputMapState, changeSet?: ChangeSet | null): BreakStatementState;
+    removeOutput(output: InputMapState, changeSet?: ChangeSet | null): BreakStatementState;
+    setParent(parent: LoopState, changeSet?: ChangeSet | null): BreakStatementState;
+    setValueWriter(valueWriter: ValueWritingEntityState | null, changeSet?: ChangeSet | null): BreakStatementState;
+    removeValueWriter(changeSet?: ChangeSet | null): BreakStatementState;
+    initChildren(changeSet?: ChangeSet | null): BreakStatementState;
+    subscribe(): BreakStatementState;
+    unsubscribe(): BreakStatementState;
+    metaSync(changedData: Partial<IBreakStatement_meta | IBreakStatement | IBreakStatementTransfer | IBreakStatementShallowTransfer>, changeSet?: ChangeSet | null): BreakStatementState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IBreakStatementShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<EntityState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IBreakStatement_meta;
+    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(options?: IEntityRecursionOptions): IBreakStatementGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): BreakStatementState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    getDefaultValue(): LiteralValueState | null;
+    setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): BreakStatementState;
+    clone(changeSet?: ChangeSet | null, parent?: LoopState | null, newId?: string | null, subscribe?: boolean): BreakStatementState;
+    getMasterInputWithValueWriterFromAllInstances(input: TerminationInputMapState): TerminationInputMapState;
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<BreakStatementState>;
+    syncInputs(changeSet?: ChangeSet | null): IChangeSet<BreakStatementState>;
+    setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): BreakStatementState;
+    removeDataType(changeSet?: ChangeSet | null): BreakStatementState;
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+}
+export type BreakStatementPayloadUnion = BreakStatementState | BreakStatementTypesUnion;

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

@@ -0,0 +1,3 @@
+export * from './break-statement';
+import * as breakStatementValidation from './validation/logic-validation';
+export { breakStatementValidation };

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

@@ -0,0 +1,6 @@
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+import { EntityError } from '../../error';
+import { BreakStatementState } from '../break-statement';
+
+export declare function validateAsync(self: BreakStatementState, options?: YieldOptions): Promise<EntityError[]>;
+export declare function validate(self: BreakStatementState): EntityError[];

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

@@ -0,0 +1,217 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getBreakStatementTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.BreakStatement>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.BreakStatement;
+}, {
+    type: EntityType.BreakStatement;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getBreakStatementReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.BreakStatement>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.BreakStatement;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.BreakStatement;
+    entityId: string;
+}>;
+export declare function getBreakStatementBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.BreakStatement>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.BreakStatement;
+    id: string;
+}, {
+    type: EntityType.BreakStatement;
+    id: string;
+}>;
+export declare function getBreakStatementMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.BreakStatement>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.BreakStatement;
+    id: string;
+    version: string;
+    x: number;
+    y: number;
+}, {
+    type: EntityType.BreakStatement;
+    id: string;
+    version: string;
+    x: number;
+    y: number;
+}>;
+export declare function getBreakStatementGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.BreakStatement>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.BreakStatement;
+    id: string;
+}, {
+    type: EntityType.BreakStatement;
+    id: string;
+}>;
+export declare function getBreakStatementNestedEntitiesSchema(): z.ZodObject<{
+    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
+    outputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InputMap;
+    }, {
+        type: EntityType.InputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    throws: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InputMap;
+    }, {
+        type: EntityType.InputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    parent: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.Loop>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Loop;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Loop;
+        entityId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    outputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Loop;
+        entityId: string;
+    };
+    throws?: Record<string, any> | {
+        type: EntityType.InputMap;
+    } | undefined;
+}, {
+    outputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Loop;
+        entityId: string;
+    };
+    throws?: Record<string, any> | {
+        type: EntityType.InputMap;
+    } | undefined;
+}>;
+export declare function getBreakStatementSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.BreakStatement>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+} & {
+    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
+    outputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InputMap;
+    }, {
+        type: EntityType.InputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    throws: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InputMap;
+    }, {
+        type: EntityType.InputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    parent: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.Loop>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Loop;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Loop;
+        entityId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    outputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Loop;
+        entityId: string;
+    };
+    type: EntityType.BreakStatement;
+    id: string;
+    version: string;
+    x: number;
+    y: number;
+    throws?: Record<string, any> | {
+        type: EntityType.InputMap;
+    } | undefined;
+}, {
+    outputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Loop;
+        entityId: string;
+    };
+    type: EntityType.BreakStatement;
+    id: string;
+    version: string;
+    x: number;
+    y: number;
+    throws?: Record<string, any> | {
+        type: EntityType.InputMap;
+    } | undefined;
+}>;

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

@@ -0,0 +1,76 @@
+import { BaseEntityNames, BuiltInBaseEntityTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IBuiltInBaseEntity, IBuiltInBaseEntity_meta, IBuiltInBaseEntityGenerationTarget, IBuiltInBaseEntityReference, IBuiltInBaseEntityShallowTransfer, IBuiltInBaseEntityTransfer } from '../../../definitions';
+import { BaseState, IEntityPersistanceOptions, IEntityRecursionOptions, IReadOnlyEntityPersistanceRepository } from '../base';
+import { PropertyState } from '../property';
+import { ProjectState } from '../project/project';
+import { PrimitiveEntityState } from '../primitive-entity';
+import { ActionDescriptorState } from '../action-descriptor';
+import { EntityError } from '../../state/error';
+import { EntityState } from '../types';
+import { DefinitionEntityState } from '../definition-entity';
+import { VersionedState } from '../version';
+import { ChangeSet } from '../change-set';
+import { DataTypeState } from '../data-type';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare class BuiltInBaseEntityState extends VersionedState implements BaseState, IBuiltInBaseEntity {
+    initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer;
+    readonly id: BaseEntityNames;
+    readonly version: EntityVersion;
+    readonly name: BaseEntityNames;
+    readonly description: string | null;
+    readonly type: EntityType.BuiltInBaseEntity;
+    readonly abstract: boolean;
+    readonly static: boolean;
+    readonly additionalProperties: boolean;
+    readonly properties: PropertyState[];
+    readonly allPropertiesImplement: PropertyState | null;
+    readonly additionalPropertiesDataType: DataTypeState | null;
+    readonly methods: ActionDescriptorState[];
+    readonly abstractMethods: ActionDescriptorState[];
+    readonly extends: BuiltInBaseEntityState | PrimitiveEntityState | null;
+    readonly interactive: boolean;
+    errors: EntityError[];
+    project: ProjectState;
+    constructor(initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer, parentProjectState: ProjectState);
+    static repository: IReadOnlyEntityPersistanceRepository;
+    get allMethods(): ActionDescriptorState[];
+    get allProperties(): PropertyState[];
+    get allBaseMethodsFromOriginalParents(): ActionDescriptorState[];
+    get allBasePropertiesFromOriginalParents(): PropertyState[];
+    get allBasePropertiesFromExtendedAndImplementedEntities(): PropertyState[];
+    get allBaseMethodsFromExtendedAndImplementedEntities(): (ActionDescriptorState | ActionDescriptorState)[];
+    get extendedPropertiesFromOriginalParents(): PropertyState[];
+    get implementedPropertiesFromOriginalParents(): PropertyState[];
+    get extendedProperties(): PropertyState[];
+    get ownDeclaredMethods(): ActionDescriptorState[];
+    get ownDeclaredProperties(): PropertyState[];
+    subscribe(): BuiltInBaseEntityState;
+    unsubscribe(): BuiltInBaseEntityState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BuiltInBaseEntityState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IBuiltInBaseEntity_meta;
+    toJSON(seenEntities?: Set<EntityId>): IBuiltInBaseEntityTransfer | IBuiltInBaseEntityReference;
+    toReference(_?: IEntityRecursionOptions): IBuiltInBaseEntityReference;
+    toShallowJSON(_?: IEntityRecursionOptions): IBuiltInBaseEntityShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(_?: IEntityRecursionOptions): IBuiltInBaseEntityGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): BuiltInBaseEntityState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    implement(newEntityName: string, changeSet?: ChangeSet | null, newId?: string): DefinitionEntityState;
+    getAllPropertiesImplements(): PropertyState[];
+    getAllInteractiveMethods(): ActionDescriptorState[];
+    getRawDefaultValue(): {
+        [propertyName: string]: any;
+    };
+}
+export type BuiltInBaseEntityPayloadUnion = BuiltInBaseEntityState | BuiltInBaseEntityTypesUnion;

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

@@ -0,0 +1 @@
+export * from './built-in-base-entity';