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

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

@@ -1,185 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

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