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

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

@@ -0,0 +1,179 @@
+import { EntityId, EntityType, IFunctionCall, IFunctionCallTransfer, IFunctionCallReference, IFunctionCallShallowTransfer, ElementShallowTransfer, IFunctionCallGenerationTarget, ElementGenerationTarget, FunctionCallTypesUnion, EntityVersion, IFunctionCall_meta } from '../../../definitions';
+import { BaseCanvasDraggableState, UserManagedBaseState, CallableEntityClass, ChildEntityBaseClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate, ValueWritingEntityClass } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState, ValueReadingEntityState } from '../types';
+import { FunctionDeclarationState } from '../function-declaration';
+import { ActionInputMapState } from '../input-map';
+import { ActionOutputMapState } from '../output-map';
+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 FunctionCallDependencyField {
+    FunctionCallParentField = "function-call-parent-field",
+    FunctionCallDeclarationField = "function-call-declaration-field"
+}
+export declare class FunctionCallState extends UserManagedVersionedState implements IFunctionCall, UserManagedBaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, CallableEntityClass, ChildEntityBaseClass, PassThroughCallableEntityClass, ValueWritingEntityClass {
+    initialData: IFunctionCall | IFunctionCallTransfer;
+    readonly id: EntityId;
+    x: number;
+    y: number;
+    readonly type: EntityType.FunctionCall;
+    catchesError: boolean;
+    writesValues: ValueReadingEntityState[];
+    successCalls: CallableEntityState[];
+    errorCalls: CallableEntityState[];
+    declaration: FunctionDeclarationState;
+    inputs: ActionInputMapState[];
+    outputs: ActionOutputMapState[];
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    error: ActionOutputMapState | null;
+    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: IFunctionCall | IFunctionCallTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.FunctionCall;
+    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): IFunctionCallTransfer;
+    static fromGenerationTarget(data: IFunctionCallGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): FunctionCallState;
+    static validateGenerationTarget(data: IFunctionCallGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IFunctionCallGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IFunctionCallGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IFunctionCallGenerationTarget>;
+    };
+    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(): FunctionCallState;
+    snapshot(): FunctionCallState;
+    /**
+     * 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 {FunctionCallState} snapshotInstance
+     * @returns {FunctionCallState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: FunctionCallState): FunctionCallState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<FunctionCallState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<FunctionCallState>>;
+    updateWithShallowTransfer(transfer: IFunctionCallShallowTransfer, changeSet?: ChangeSet | null): FunctionCallState;
+    updateWithGenerationTarget(transfer: Partial<IFunctionCallGenerationTarget>, changeSet?: ChangeSet | null): FunctionCallState;
+    hydrateAncestors(): IChangeSet<FunctionCallState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    get calledBy(): CallerEntityState[];
+    removeInput(input: ActionInputMapState, changeSet?: ChangeSet | null): FunctionCallState;
+    addInput(input: ActionInputMapState, changeSet?: ChangeSet | null): FunctionCallState;
+    addOutput(output: ActionOutputMapState, changeSet?: ChangeSet | null): FunctionCallState;
+    removeOutput(output: ActionOutputMapState, changeSet?: ChangeSet | null): FunctionCallState;
+    addValueReader(entity: ValueReadingEntityState, changeSet?: ChangeSet | null): FunctionCallState;
+    removeValueReader(valueReader: ValueReadingEntityState, changeSet?: ChangeSet | null): FunctionCallState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): FunctionCallState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): FunctionCallState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): FunctionCallState;
+    addErrorCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): FunctionCallState;
+    addSuccessCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): FunctionCallState;
+    removeCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): FunctionCallState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): FunctionCallState;
+    setError(error: ActionOutputMapState | null, changeSet?: ChangeSet | null): FunctionCallState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): FunctionCallState;
+    setDeclaration(declaration: FunctionDeclarationState): FunctionCallState;
+    initChildren(changeSet?: ChangeSet | null): FunctionCallState;
+    subscribe(): FunctionCallState;
+    unsubscribe(): FunctionCallState;
+    metaSync(changedData: Partial<IFunctionCall_meta | IFunctionCall | IFunctionCallTransfer | IFunctionCallShallowTransfer>, changeSet?: ChangeSet | null): FunctionCallState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IFunctionCallShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IFunctionCall_meta;
+    toJSON(seenEntities?: Set<EntityId>): IFunctionCallTransfer | IFunctionCallReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IFunctionCallTransfer | IFunctionCallReference;
+    toReference(options?: IEntityRecursionOptions): IFunctionCallReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IFunctionCallShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IFunctionCallGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): FunctionCallState;
+    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): FunctionCallState;
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    removeUnrecognizedOutputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    syncInputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    syncOutputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    getUnusedInputs(): ActionInputMapState[];
+    getUnusedOutputs(): ActionOutputMapState[];
+    getUsedInputs(): ActionInputMapState[];
+    getUsedOutputs(): ActionOutputMapState[];
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+}
+export type FunctionCallPayloadUnion = FunctionCallState | FunctionCallTypesUnion;

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

@@ -0,0 +1,3 @@
+export * from './function-call';
+import * as functionCallValidation from './validation/logic-validation';
+export { functionCallValidation };

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

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

package/dist/tree/state/function-call/validation/validation-schema.d.ts

@@ -0,0 +1,267 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getFunctionCallTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.FunctionCall>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.FunctionCall;
+}, {
+    type: EntityType.FunctionCall;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getFunctionCallReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.FunctionCall>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.FunctionCall;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.FunctionCall;
+    entityId: string;
+}>;
+export declare function getFunctionCallBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.FunctionCall>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.FunctionCall;
+    id: string;
+}, {
+    type: EntityType.FunctionCall;
+    id: string;
+}>;
+export declare function getFunctionCallMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.FunctionCall>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.FunctionCall;
+    id: string;
+    version: string;
+    x: number;
+    y: number;
+}, {
+    type: EntityType.FunctionCall;
+    id: string;
+    version: string;
+    x: number;
+    y: number;
+}>;
+export declare function getFunctionCallGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.FunctionCall>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.FunctionCall;
+    id: string;
+}, {
+    type: EntityType.FunctionCall;
+    id: string;
+}>;
+export declare function getFunctionCallNestedEntitiesSchema(): z.ZodObject<{
+    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.FunctionDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.FunctionDeclaration;
+    }, {
+        type: EntityType.FunctionDeclaration;
+    }>, 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.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    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.FunctionDeclaration;
+    };
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    writesValues: any[];
+    parent?: any;
+    error?: Record<string, any> | {
+        type: EntityType.OutputMap;
+    } | undefined;
+}, {
+    declaration: Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    };
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    writesValues: any[];
+    parent?: any;
+    error?: Record<string, any> | {
+        type: EntityType.OutputMap;
+    } | undefined;
+}>;
+export declare function getFunctionCallSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.FunctionCall>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+} & {
+    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.FunctionDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.FunctionDeclaration;
+    }, {
+        type: EntityType.FunctionDeclaration;
+    }>, 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.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    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.FunctionDeclaration;
+    };
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    type: EntityType.FunctionCall;
+    id: string;
+    version: string;
+    writesValues: any[];
+    x: number;
+    y: number;
+    parent?: any;
+    error?: Record<string, any> | {
+        type: EntityType.OutputMap;
+    } | undefined;
+}, {
+    declaration: Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    };
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    type: EntityType.FunctionCall;
+    id: string;
+    version: string;
+    writesValues: any[];
+    x: number;
+    y: number;
+    parent?: any;
+    error?: Record<string, any> | {
+        type: EntityType.OutputMap;
+    } | undefined;
+}>;

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

@@ -0,0 +1,192 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, FunctionDeclarationTypesUnion, IFunctionCallTransfer, IFunctionDeclaration, IFunctionDeclaration_meta, IFunctionDeclarationGenerationTarget, IFunctionDeclarationReference, IFunctionDeclarationShallowTransfer, IFunctionDeclarationTransfer, IInternalCallTransfer } from '../../../definitions';
+import { BaseCanvasDraggableState, UserManagedBaseState, ChildEntityBaseClass, EntityWithLogicScopeClass, EntryPointEntityClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
+import { ArgumentDeclarationState } from '../argument-declaration';
+import { ReturnStatementState } from '../return-statement';
+import { CallableEntityState, CanvasEntityState, EntityState, EntityWithLogicScopeState, UserManagedEntityState, VariableState } from '../types';
+import { ProjectState } from '../project/project';
+import { InstalledProjectState } from '../installed-project';
+import { DefinitionEntityState } from '../definition-entity';
+import { LoopState } from '../loop';
+import { ActionDescriptorState } from '../action-descriptor';
+import { VariableInstanceState } from '../variable-instance';
+import { EntityError, EntityGenerationError } from '../error';
+import { FunctionCallState } from '../function-call';
+import { GenerationExplanationIds } from '../validate';
+import { InternalCallState } from '../internal-call';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { PropertyState } from '../property';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+import { DataTypeState } from '../data-type';
+import { InputMapState } from '../input-map';
+
+export declare enum FunctionDeclarationDependencyField {
+    FunctionDeclarationImplements = "function-declaration-implements",
+    FunctionDeclarationExtends = "function-declaration-extends",
+    FunctionDeclarationDataType = "function-declaration-data-type",
+    FunctionDeclarationDataTypeEntity = "function-declaration-data-type-entity"
+}
+export declare class FunctionDeclarationState extends UserManagedVersionedState implements IFunctionDeclaration, UserManagedBaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, ChildEntityBaseClass, EntityWithLogicScopeClass, EntryPointEntityClass {
+    initialData: IFunctionDeclarationTransfer | IFunctionDeclaration;
+    readonly id: EntityId;
+    name: string;
+    codeName: string | null;
+    description: string | null;
+    x: number;
+    y: number;
+    collapsed: boolean;
+    private: boolean;
+    index: number | null;
+    readonly type: EntityType.FunctionDeclaration;
+    implements: ActionDescriptorState | null;
+    extends: FunctionDeclarationState | null;
+    dataType: DataTypeState | null;
+    inputs: ArgumentDeclarationState[];
+    calls: CallableEntityState[];
+    parent: ProjectState | InstalledProjectState | DefinitionEntityState | LoopState;
+    detachedChildren: CanvasEntityState[];
+    errors: EntityError[];
+    project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    suggestion: boolean;
+    constructor(initialData: IFunctionDeclaration | IFunctionDeclarationTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.FunctionDeclaration;
+    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): IFunctionDeclarationTransfer;
+    static fromGenerationTarget(data: IFunctionDeclarationGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): FunctionDeclarationState;
+    static validateGenerationTarget(data: IFunctionDeclarationGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IFunctionDeclarationGenerationTarget;
+    };
+    get isExtendedMethod(): boolean;
+    get returnStatements(): ReturnStatementState[];
+    validateGeneratedUpdate(data: Partial<IFunctionDeclarationGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IFunctionDeclarationGenerationTarget>;
+    };
+    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(): FunctionDeclarationState;
+    snapshot(): FunctionDeclarationState;
+    /**
+     * 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 {FunctionDeclarationState} snapshotInstance
+     * @returns {FunctionDeclarationState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: FunctionDeclarationState): FunctionDeclarationState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<FunctionDeclarationState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<FunctionDeclarationState>>;
+    updateWithShallowTransfer(transfer: IFunctionDeclarationShallowTransfer, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    updateWithGenerationTarget(transfer: Partial<IFunctionDeclarationGenerationTarget>, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    hydrateAncestors(): IChangeSet<FunctionDeclarationState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
+    replaceDetachedChild(existingChild: CanvasEntityState, newChild: CanvasEntityState): FunctionDeclarationState;
+    subscribeDetachedChild(child: CanvasEntityState): FunctionDeclarationState;
+    unsubscribeDetachedChild(child: CanvasEntityState): FunctionDeclarationState;
+    addInputDeclaration(input: ArgumentDeclarationState, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    removeInputDeclaration(input: ArgumentDeclarationState, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    setParent(parent: ProjectState | InstalledProjectState | DefinitionEntityState | LoopState, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    setImplements(implementsEntity: ActionDescriptorState | null, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    setExtends(extendsEntity: FunctionDeclarationState | null, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    addCall(entity: CallableEntityState, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    removeCall(entity: CallableEntityState, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    initChildren(changeSet?: ChangeSet | null): FunctionDeclarationState;
+    subscribe(): FunctionDeclarationState;
+    unsubscribe(): FunctionDeclarationState;
+    metaSync(changedData: Partial<IFunctionDeclaration_meta | IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationShallowTransfer>, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IFunctionDeclarationShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IFunctionDeclaration_meta;
+    toJSON(seenEntities?: Set<EntityId>): IFunctionDeclarationTransfer | IFunctionDeclarationReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IFunctionDeclarationTransfer | IFunctionDeclarationReference;
+    toReference(options?: IEntityRecursionOptions): IFunctionDeclarationReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IFunctionDeclarationShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IFunctionDeclarationGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): FunctionDeclarationState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(changeSet?: ChangeSet | null, parent?: InstalledProjectState | ProjectState | DefinitionEntityState | LoopState | null, newId?: string | null, subscribe?: boolean, cloneBody?: boolean): FunctionDeclarationState;
+    getVariableInstances(): VariableInstanceState[];
+    getArgument(id: EntityId): ArgumentDeclarationState | null;
+    createCall(changeSet?: ChangeSet | null, parent?: EntityWithLogicScopeState | ProjectState, overrides?: Partial<IFunctionCallTransfer>): FunctionCallState;
+    createInternalCall(changeSet: (ChangeSet | null) | undefined, parent: VariableState, overrides?: Partial<IInternalCallTransfer>): InternalCallState;
+    addReturnStatement(statement: ReturnStatementState): FunctionDeclarationState;
+    removeReturnStatement(statement: ReturnStatementState): FunctionDeclarationState;
+    getUniqueOutputProperties(): PropertyState[];
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
+    syncInputs(changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
+    getUniqueInputMaps(): InputMapState[];
+    reAttachAllTerminationInputMapsToDeclarations(changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
+    inferDataTypeFromReturnStatements(changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
+    setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    removeDataType(changeSet?: ChangeSet | null): FunctionDeclarationState;
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+}
+export type FunctionDeclarationPayloadUnion = FunctionDeclarationState | FunctionDeclarationTypesUnion;

package/dist/tree/state/function-declaration/index.d.ts

@@ -0,0 +1,3 @@
+export * from './function-declaration';
+import * as functionDeclarationValidation from './validation/logic-validation';
+export { functionDeclarationValidation };

package/dist/tree/state/function-declaration/remove-unrecognized-inputs/as-http-endpoint-handler.d.ts

@@ -0,0 +1,4 @@
+import { ChangeSet, IChangeSet } from '../../change-set';
+import { FunctionDeclarationState } from '../function-declaration';
+
+export declare function removeUnrecognizedInputsAsHttpEndpointHandler(self: FunctionDeclarationState, _changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;

package/dist/tree/state/function-declaration/remove-unrecognized-inputs/as-loop-body.d.ts

@@ -0,0 +1,6 @@
+import { ChangeSet, IChangeSet } from '../../change-set';
+import { FunctionDeclarationState } from '../function-declaration';
+import { ArgumentDeclarationState } from '../../argument-declaration';
+
+export declare function checkArgumentIsLoopAggregateResult(self: FunctionDeclarationState, argument: ArgumentDeclarationState): boolean;
+export declare function removeUnrecognizedInputsAsLoopBody(self: FunctionDeclarationState, _changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;