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

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

@@ -0,0 +1,178 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IOperation, IOperationGenerationTarget, IOperationReference, IOperationShallowTransfer, IOperationTransfer, OperationTypesUnion, EntityVersion, IOperation_meta } from '../../../definitions';
+import { BaseCanvasDraggableState, UserManagedBaseState, CallableEntityClass, ChildEntityBaseClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate, ValueWritingEntityClass } from '../base';
+import { ActionDescriptorState } from '../action-descriptor/action-descriptor';
+import { ActionInputMapState } from '../input-map';
+import { ActionOutputMapState } from '../output-map';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState, ValueReadingEntityState } from '../types';
+import { ProjectState } from '../project/project';
+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 { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare enum OperationDependencyField {
+    Parent = "parent"
+}
+export declare class OperationState extends UserManagedVersionedState implements IOperation, UserManagedBaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, ValueWritingEntityClass, CallableEntityClass, ChildEntityBaseClass, PassThroughCallableEntityClass {
+    initialData: IOperation | IOperationTransfer;
+    readonly id: EntityId;
+    x: number;
+    y: number;
+    readonly type: EntityType.Operation;
+    catchesError: boolean;
+    declaration: ActionDescriptorState;
+    writesValues: ValueReadingEntityState[];
+    inputs: ActionInputMapState[];
+    outputs: ActionOutputMapState[];
+    successCalls: CallableEntityState[];
+    errorCalls: CallableEntityState[];
+    error: ActionOutputMapState | null;
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    parent: EntityWithLogicScopeState | ProjectState;
+    errors: EntityError[];
+    project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    constructor(initialData: IOperation | IOperationTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.Operation;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
+    static MUTABLE_BASE_PROPERTIES: string[];
+    static INMUTABLE_BASE_PROPERTIES: string[];
+    static BASE_PROPERTIES: string[];
+    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): IOperationTransfer;
+    static fromGenerationTarget(data: IOperationGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): OperationState;
+    static validateGenerationTarget(data: IOperationGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IOperationGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IOperationGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IOperationGenerationTarget>;
+    };
+    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(): OperationState;
+    snapshot(): OperationState;
+    /**
+     * 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 {OperationState} snapshotInstance
+     * @returns {OperationState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: OperationState): OperationState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<OperationState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<OperationState>>;
+    updateWithShallowTransfer(transfer: IOperationShallowTransfer, changeSet?: ChangeSet | null): OperationState;
+    updateWithGenerationTarget(transfer: Partial<IOperationGenerationTarget>, changeSet?: ChangeSet | null): OperationState;
+    hydrateAncestors(): IChangeSet<OperationState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    get calledBy(): CallerEntityState[];
+    removeInput(input: ActionInputMapState, changeSet?: ChangeSet | null): OperationState;
+    addInput(input: ActionInputMapState, changeSet?: ChangeSet | null): OperationState;
+    addOutput(output: ActionOutputMapState, changeSet?: ChangeSet | null): OperationState;
+    removeOutput(output: ActionOutputMapState, changeSet?: ChangeSet | null): OperationState;
+    addValueReader(entity: ValueReadingEntityState, changeSet?: ChangeSet | null): OperationState;
+    removeValueReader(valueReader: ValueReadingEntityState, changeSet?: ChangeSet | null): OperationState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): OperationState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): OperationState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): OperationState;
+    addErrorCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): OperationState;
+    addSuccessCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): OperationState;
+    removeCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): OperationState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): OperationState;
+    setError(error: ActionOutputMapState | null, changeSet?: ChangeSet | null): OperationState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): OperationState;
+    setDeclaration(declaration: ActionDescriptorState): OperationState;
+    initChildren(changeSet?: ChangeSet | null): OperationState;
+    subscribe(): OperationState;
+    unsubscribe(): OperationState;
+    metaSync(changedData: Partial<IOperation_meta | IOperation | IOperationTransfer | IOperationShallowTransfer>, changeSet?: ChangeSet | null): OperationState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IOperationShallowTransfer | 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(): IOperation_meta;
+    toJSON(seenEntities?: Set<EntityId>): IOperationTransfer | IOperationReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IOperationTransfer | IOperationReference;
+    toReference(options?: IEntityRecursionOptions): IOperationReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IOperationShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IOperationGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): OperationState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): OperationState;
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    removeUnrecognizedOutputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    syncInputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    syncOutputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    getUnusedInputs(): ActionInputMapState[];
+    getUnusedOutputs(): ActionOutputMapState[];
+    getUsedInputs(): ActionInputMapState[];
+    getUsedOutputs(): ActionOutputMapState[];
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+}
+export type OperationPayloadUnion = OperationState | OperationTypesUnion;

package/dist/tree/state/operation/validation/logic-validation.d.ts

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

package/dist/tree/state/operation/validation/validation-schema.d.ts

@@ -0,0 +1,273 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getOperationTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.Operation>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Operation;
+}, {
+    type: EntityType.Operation;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getOperationReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.Operation>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.Operation;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.Operation;
+    entityId: string;
+}>;
+export declare function getOperationBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Operation>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Operation;
+    id: string;
+}, {
+    type: EntityType.Operation;
+    id: string;
+}>;
+export declare function getOperationMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Operation>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Operation;
+    id: string;
+    version: string;
+    x: number;
+    y: number;
+}, {
+    type: EntityType.Operation;
+    id: string;
+    version: string;
+    x: number;
+    y: number;
+}>;
+export declare function getOperationGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Operation>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Operation;
+    id: string;
+}, {
+    type: EntityType.Operation;
+    id: string;
+}>;
+export declare function getOperationNestedEntitiesSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Operation>;
+} & {
+    successCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    errorCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
+    writesValues: z.ZodArray<z.ZodTypeAny, "many">;
+    declaration: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ActionDescriptor;
+    }, {
+        type: EntityType.ActionDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+    inputs: 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">;
+    outputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    error: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    parent: z.ZodUnion<[z.ZodTypeAny, z.ZodObject<{
+        entityType: z.ZodLiteral<EntityType.Project>;
+        entityId: z.ZodString;
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    declaration: Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    };
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    error: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    type: EntityType.Operation;
+    id: string;
+    writesValues: any[];
+    parent?: any;
+}, {
+    declaration: Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    };
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    error: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    type: EntityType.Operation;
+    id: string;
+    writesValues: any[];
+    parent?: any;
+}>;
+export declare function getOperationSchema(): z.ZodObject<{
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+} & {
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Operation>;
+    successCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    errorCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
+    writesValues: z.ZodArray<z.ZodTypeAny, "many">;
+    declaration: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ActionDescriptor;
+    }, {
+        type: EntityType.ActionDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+    inputs: 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">;
+    outputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    error: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    parent: z.ZodUnion<[z.ZodTypeAny, z.ZodObject<{
+        entityType: z.ZodLiteral<EntityType.Project>;
+        entityId: z.ZodString;
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    declaration: Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    };
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    error: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    type: EntityType.Operation;
+    id: string;
+    version: string;
+    writesValues: any[];
+    x: number;
+    y: number;
+    parent?: any;
+}, {
+    declaration: Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    };
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    error: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    type: EntityType.Operation;
+    id: string;
+    version: string;
+    writesValues: any[];
+    x: number;
+    y: number;
+    parent?: any;
+}>;

package/dist/tree/state/output-map/index.d.ts

@@ -0,0 +1,3 @@
+export * from './output-map';
+import * as outputMapValidation from './validation/logic-validation';
+export { outputMapValidation };

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

@@ -0,0 +1,171 @@
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IActionOutputMap, IActionOutputMapTransfer, IOutputMap, IOutputMap_meta, IOutputMapGenerationTarget, IOutputMapReference, IOutputMapShallowTransfer, IOutputMapTransfer, IVariableOutputMap, IVariableOutputMapTransfer, OutputMapParentChildRelation, OutputMapTypesUnion } from '../../../definitions';
+import { UserManagedBaseState, ChildEntityBaseClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate, ValueValidationCallback, ValueWritingEntityClass } from '../base';
+import { EntityState, PassThroughCallableEntityWithOutputsState, UserManagedEntityState, ValueReadingEntityState } from '../types';
+import { ProjectState } from '../project/project';
+import { VariableDeclarationState } from '../variable-declaration';
+import { VariableInstanceState } from '../variable-instance';
+import { PropertyState } from '../property';
+import { EntityError, EntityGenerationError } from '../../state/error';
+import { GenerationExplanationIds } from '../validate';
+import { DataTypeState } from '../data-type';
+import { ValueDescriptorState } from '../value-descriptor';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+
+export declare enum OutputMapDependencyField {
+    Declaration = "declaration",
+    DataTypeEntity = "data-type-entity"
+}
+export declare class OutputMapState extends UserManagedVersionedState implements IOutputMap, UserManagedEntityStateTemplate, ValueWritingEntityClass, UserManagedBaseState, ChildEntityBaseClass {
+    initialData: IOutputMap | IOutputMapTransfer;
+    readonly id: EntityId;
+    index: number;
+    readonly type: EntityType.OutputMap;
+    parentRelationType?: OutputMapParentChildRelation;
+    declaration: PropertyState | ValueDescriptorState | null;
+    writesValues: ValueReadingEntityState[];
+    dataType: DataTypeState | null;
+    project: ProjectState;
+    errors: EntityError[];
+    parent: PassThroughCallableEntityWithOutputsState;
+    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: IOutputMap | IOutputMapTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.OutputMap;
+    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): IOutputMapTransfer;
+    static fromGenerationTarget(data: IOutputMapGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): OutputMapState;
+    static validateGenerationTarget(data: IOutputMapGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IOutputMapGenerationTarget;
+    };
+    get codeName(): string | null;
+    get codeNativeValueValidation(): ValueValidationCallback | null;
+    validateGeneratedUpdate(data: Partial<IOutputMapGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IOutputMapGenerationTarget>;
+    };
+    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(): OutputMapState;
+    snapshot(): OutputMapState;
+    /**
+     * 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 {OutputMapState} snapshotInstance
+     * @returns {OutputMapState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: OutputMapState): OutputMapState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<OutputMapState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<OutputMapState>>;
+    updateWithShallowTransfer(transfer: IOutputMapShallowTransfer, changeSet?: ChangeSet | null): OutputMapState;
+    updateWithGenerationTarget(transfer: Partial<IOutputMapGenerationTarget>, changeSet?: ChangeSet | null): OutputMapState;
+    hydrateAncestors(): IChangeSet<OutputMapState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<OutputMapState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<OutputMapState>;
+    addValueReader(entity: ValueReadingEntityState, changeSet?: ChangeSet | null): OutputMapState;
+    removeValueReader(valueReader: ValueReadingEntityState, changeSet?: ChangeSet | null): OutputMapState;
+    setParent(parent: PassThroughCallableEntityWithOutputsState, changeSet?: ChangeSet | null): OutputMapState;
+    setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): OutputMapState;
+    removeDataType(changeSet?: ChangeSet | null): OutputMapState;
+    setDeclaration(declaration: PropertyState | ValueDescriptorState, changeSet?: ChangeSet | null): OutputMapState;
+    initChildren(changeSet?: ChangeSet | null): OutputMapState;
+    subscribe(): OutputMapState;
+    unsubscribe(): OutputMapState;
+    metaSync(changedData: Partial<IOutputMap_meta | IOutputMap | IOutputMapTransfer | IOutputMapShallowTransfer>, changeSet?: ChangeSet | null): OutputMapState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IOutputMapShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<OutputMapState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IOutputMap_meta;
+    toJSON(seenEntities?: Set<EntityId>): IOutputMapTransfer | IOutputMapReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IOutputMapTransfer | IOutputMapReference;
+    toReference(options?: IEntityRecursionOptions): IOutputMapReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IOutputMapShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IOutputMapGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): OutputMapState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(changeSet?: ChangeSet | null, parent?: PassThroughCallableEntityWithOutputsState | null, newId?: string | null, subscribe?: boolean): OutputMapState;
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+}
+export declare class VariableOutputMapState extends OutputMapState implements IVariableOutputMap {
+    declaration: PropertyState;
+    parent: VariableInstanceState | VariableDeclarationState;
+    errors: EntityError[];
+    constructor(initialVariableAndTerminationInputMapData: IVariableOutputMap | IVariableOutputMapTransfer, parentProjectState: ProjectState);
+    toJSON(seenEntities?: Set<EntityId>): IVariableOutputMap | IOutputMapReference;
+}
+export declare class ActionOutputMapState extends OutputMapState implements IActionOutputMap {
+    declaration: PropertyState | ValueDescriptorState | null;
+    parent: PassThroughCallableEntityWithOutputsState;
+    errors: EntityError[];
+    constructor(initialActionOutputMapData: IActionOutputMap | IActionOutputMapTransfer, parentProjectState: ProjectState);
+    toJSON(seenEntities?: Set<EntityId>): IActionOutputMap | IOutputMapReference;
+}
+export type OutputMapPayloadUnion = OutputMapState | OutputMapTypesUnion;

package/dist/tree/state/output-map/validation/logic-validation.d.ts

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