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

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

@@ -0,0 +1,3 @@
+export * from './installed-project';
+import * as installedProjectValidation from './validation/logic-validation';
+export { installedProjectValidation };

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

@@ -0,0 +1,147 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IInstalledProject, IInstalledProjectGenerationTarget, IInstalledProjectReference, IInstalledProjectShallowTransfer, IInstalledProjectTransfer, IInstalledProject_meta, IProjectReference, InstalledProjectTypesUnion } from '../../../definitions';
+import { BaseCanvasDraggableState, UserManagedBaseState, ChildEntityBaseClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
+import { FunctionDeclarationState } from '../function-declaration';
+import { GlobalEventState } from '../global-event';
+import { ProjectState } from '../project/project';
+import { EntityError, EntityGenerationError } from '../error';
+import { EntityState, UserManagedEntityState } from '../types';
+import { GenerationExplanationIds } from '../validate';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare class InstalledProjectState extends UserManagedVersionedState implements IInstalledProject, UserManagedEntityStateTemplate, UserManagedBaseState, BaseCanvasDraggableState, ChildEntityBaseClass {
+    initialData: IInstalledProject | IInstalledProjectTransfer;
+    readonly id: EntityId;
+    readonly name: string;
+    readonly codeName: string | null;
+    readonly description: string | null;
+    x: number;
+    y: number;
+    readonly type: EntityType.InstalledProject;
+    implements: IProjectReference;
+    functions: FunctionDeclarationState[];
+    events: GlobalEventState[];
+    parent: 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: IInstalledProject | IInstalledProjectTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.InstalledProject;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
+    static MUTABLE_BASE_PROPERTIES: string[];
+    static INMUTABLE_BASE_PROPERTIES: string[];
+    static BASE_PROPERTIES: string[];
+    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): IInstalledProjectTransfer;
+    static fromGenerationTarget(data: IInstalledProjectGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): InstalledProjectState;
+    static validateGenerationTarget(data: IInstalledProjectGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IInstalledProjectGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IInstalledProjectGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IInstalledProjectGenerationTarget>;
+    };
+    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(): InstalledProjectState;
+    snapshot(): InstalledProjectState;
+    /**
+     * 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 {InstalledProjectState} snapshotInstance
+     * @returns {InstalledProjectState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: InstalledProjectState): InstalledProjectState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<InstalledProjectState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<InstalledProjectState>>;
+    updateWithShallowTransfer(transfer: IInstalledProjectShallowTransfer, changeSet?: ChangeSet | null): InstalledProjectState;
+    updateWithGenerationTarget(transfer: Partial<IInstalledProjectGenerationTarget>, changeSet?: ChangeSet | null): InstalledProjectState;
+    hydrateAncestors(): IChangeSet<InstalledProjectState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<InstalledProjectState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<InstalledProjectState>;
+    setParent(parent: ProjectState, changeSet?: ChangeSet | null): InstalledProjectState;
+    addFunction(func: FunctionDeclarationState, changeSet?: ChangeSet | null): InstalledProjectState;
+    removeFunction(func: FunctionDeclarationState, changeSet?: ChangeSet | null): InstalledProjectState;
+    addEvent(event: GlobalEventState, changeSet?: ChangeSet | null): InstalledProjectState;
+    removeEvent(event: GlobalEventState, changeSet?: ChangeSet | null): InstalledProjectState;
+    initChildren(changeSet?: ChangeSet | null): InstalledProjectState;
+    subscribe(): InstalledProjectState;
+    unsubscribe(): InstalledProjectState;
+    metaSync(changedData: Partial<IInstalledProject_meta | IInstalledProject | IInstalledProjectTransfer | IInstalledProjectShallowTransfer>, changeSet?: ChangeSet | null): InstalledProjectState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IInstalledProjectShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<InstalledProjectState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IInstalledProject_meta;
+    toJSON(seenEntities?: Set<EntityId>): IInstalledProjectTransfer | IInstalledProjectReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IInstalledProjectTransfer | IInstalledProjectReference;
+    toReference(options?: IEntityRecursionOptions): IInstalledProjectReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IInstalledProjectShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IInstalledProjectGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): InstalledProjectState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(changeSet?: ChangeSet | null, parent?: ProjectState | null, newId?: string | null, subscribe?: boolean): InstalledProjectState;
+}
+export type InstalledProjectPayloadUnion = InstalledProjectState | InstalledProjectTypesUnion;

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

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

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

@@ -0,0 +1,238 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getInstalledProjectTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.InstalledProject>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.InstalledProject;
+}, {
+    type: EntityType.InstalledProject;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getInstalledProjectReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.InstalledProject>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.InstalledProject;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.InstalledProject;
+    entityId: string;
+}>;
+export declare function getInstalledProjectBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.InstalledProject>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.InstalledProject;
+    id: string;
+}, {
+    type: EntityType.InstalledProject;
+    id: string;
+}>;
+export declare function getInstalledProjectMetaSchema(): z.ZodObject<{
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    x: number;
+    y: number;
+}, {
+    version: string;
+    x: number;
+    y: number;
+}>;
+export declare function getInstalledProjectGenerationTargetSchema(): z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function getInstalledProjectNestedEntitiesSchema(): z.ZodObject<{
+    implements: 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;
+    }>;
+    description: z.ZodNullable<z.ZodString>;
+    functions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.FunctionDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.FunctionDeclaration;
+    }, {
+        type: EntityType.FunctionDeclaration;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    events: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.GlobalEvent>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GlobalEvent;
+    }, {
+        type: EntityType.GlobalEvent;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    parent: 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, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    description: string | null;
+    implements: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+}, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    description: string | null;
+    implements: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+}>;
+export declare function getInstalledProjectSchema(): z.ZodObject<{
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+} & {
+    implements: 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;
+    }>;
+    description: z.ZodNullable<z.ZodString>;
+    functions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.FunctionDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.FunctionDeclaration;
+    }, {
+        type: EntityType.FunctionDeclaration;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    events: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.GlobalEvent>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GlobalEvent;
+    }, {
+        type: EntityType.GlobalEvent;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    parent: 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, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    version: string;
+    description: string | null;
+    implements: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    x: number;
+    y: number;
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+}, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    version: string;
+    description: string | null;
+    implements: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    x: number;
+    y: number;
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+}>;

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

@@ -0,0 +1,4 @@
+import * as internalCallValidation from './validation/logic-validation';
+export * from './internal-call';
+export * from './validation/generation-explanations';
+export { internalCallValidation };

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

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

package/dist/tree/state/internal-call/validation/generation-explanations.d.ts

@@ -0,0 +1,51 @@
+import { VariableState } from '../../types';
+import { GenerationExplanationIds } from '../../validate';
+import { ProjectState } from '../../project';
+
+export declare function generateAllAvailableMethodsThatCanBeCalledAsInternalCallsExplanation(project: ProjectState): {
+    explanations: {
+        id: GenerationExplanationIds.AllAvailableMethodsThatCanBeCalledAsInternalCalls | GenerationExplanationIds.ReasonsForMethodsNotAvailableAsInternalCalls;
+        message: string;
+    }[];
+};
+export declare function generateAvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntitiesExplanation(project: ProjectState): {
+    explanations: {
+        id: GenerationExplanationIds.AvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntities;
+        message: string;
+    }[];
+};
+export declare function getIsGivenDeclarationIdAvailableInAnInstanciatedVarAndExplanation(declarationId: string, project: ProjectState): {
+    explanations: {
+        id: GenerationExplanationIds.NonAvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables | GenerationExplanationIds.AvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables;
+        message: string;
+    }[];
+    available: boolean;
+};
+/**
+ * Add explanation about all available methods on this variable's data-type entity.
+ * And if none, all the available methods on existing variables in the project that could be used.
+ * And if none, then all the available methods in the project that could be implemented as internal calls.
+ *
+ * If the given declaration id does exist in the given variable's data-type entity, skip.
+ *
+ * @param {string} declarationId
+ * @param {VariableState | null} variableEntityState
+ * @returns {{
+ *  explanations: {
+ *    id: GenerationExplanationIds.AvailableInternalCallsForGivenVariablesDataTypeEntity
+ *      | GenerationExplanationIds.AvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntities
+ *      | GenerationExplanationIds.AllAvailableMethodsThatCanBeCalledAsInternalCalls
+ *      | GenerationExplanationIds.ReasonsForMethodsNotAvailableAsInternalCalls
+ *      | GenerationExplanationIds.NonAvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables
+ *      | GenerationExplanationIds.AvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables
+ *      | GenerationExplanationIds.InternalCalls;
+ *    message: string;
+ *  }[];
+ * }}
+ */
+export declare function generateAvailableInternalCallsExplanation(project: ProjectState, declarationId: string | null, variableEntityState: VariableState | null): {
+    explanations: {
+        id: GenerationExplanationIds.AvailableInternalCallsForGivenVariablesDataTypeEntity | GenerationExplanationIds.AvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntities | GenerationExplanationIds.AllAvailableMethodsThatCanBeCalledAsInternalCalls | GenerationExplanationIds.ReasonsForMethodsNotAvailableAsInternalCalls | GenerationExplanationIds.NonAvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables | GenerationExplanationIds.AvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables | GenerationExplanationIds.InternalCalls;
+        message: string;
+    }[];
+};

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

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