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

package/dist/tree/built-in/built-in-base-entities/cron-job/entity.d.ts

@@ -0,0 +1,30 @@
+import { BaseEntityNames, EntityType, EntityVersion, IBuiltInBaseEntity, IBuiltInBaseEntityTransfer, LiteralValueType } from '../../../../definitions';
+import { BuiltInBaseEntityState } from '../../../state/built-in-base-entity';
+import { IValueValidationResult, PrimitiveEntityState, ProjectState, PropertyState } from '../../../state';
+import { ActionDescriptorState } from '../../../state/action-descriptor';
+import { EntityError } from '../../../state/error';
+import { CommonStringValidationErrorCodes } from '../../../utils/values-validations';
+
+export declare enum CronjobExpressionValidationErrorCodes {
+    InvalidCharacters = "cron-invalid-characters",
+    MustHaveSixFields = "cron-must-have-six-fields",
+    DayOfMonthAndWeekConflict = "cron-day-of-month-and-week-conflict"
+}
+export declare function cronJobExpressionValueValidation(self: PropertyState, value: LiteralValueType): IValueValidationResult<LiteralValueType, CronjobExpressionValidationErrorCodes | CommonStringValidationErrorCodes>;
+export declare class CronJobEntity extends BuiltInBaseEntityState {
+    initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer;
+    readonly id: BaseEntityNames;
+    readonly version: EntityVersion;
+    readonly name: BaseEntityNames;
+    readonly description: string | null;
+    readonly type: EntityType.BuiltInBaseEntity;
+    readonly abstract: boolean;
+    readonly static: boolean;
+    readonly properties: PropertyState[];
+    readonly methods: ActionDescriptorState[];
+    readonly abstractMethods: ActionDescriptorState[];
+    readonly extends: BuiltInBaseEntityState | PrimitiveEntityState | null;
+    errors: EntityError[];
+    project: ProjectState;
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/built-in-base-entities/cron-job/index.d.ts

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

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

@@ -0,0 +1,28 @@
+import { BaseEntityNames, EntityType, EntityVersion, IBuiltInBaseEntity, IBuiltInBaseEntityTransfer, LiteralValueType } from '../../../../definitions';
+import { BuiltInBaseEntityState } from '../../../state/built-in-base-entity';
+import { IValueValidationResult, PrimitiveEntityState, ProjectState, PropertyState } from '../../../state';
+import { ActionDescriptorState } from '../../../state/action-descriptor';
+import { EntityError } from '../../../state/error';
+
+export declare enum HttpStatusCodeValidationErrorCodes {
+    StatusCodeMustBeNumber = "status-code-must-be-number",
+    StatusCodeMustBeBetween100And599 = "status-code-must-be-between-100-and-599"
+}
+export declare function httpStatusCodeValueValidation(self: ActionDescriptorState, value: LiteralValueType): IValueValidationResult<LiteralValueType, HttpStatusCodeValidationErrorCodes>;
+export declare class EndpointEntity extends BuiltInBaseEntityState {
+    initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer;
+    readonly id: BaseEntityNames;
+    readonly version: EntityVersion;
+    readonly name: BaseEntityNames;
+    readonly description: string | null;
+    readonly type: EntityType.BuiltInBaseEntity;
+    readonly abstract: boolean;
+    readonly static: boolean;
+    readonly properties: PropertyState[];
+    readonly methods: ActionDescriptorState[];
+    readonly abstractMethods: ActionDescriptorState[];
+    readonly extends: BuiltInBaseEntityState | PrimitiveEntityState | null;
+    errors: EntityError[];
+    project: ProjectState;
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/built-in-base-entities/endpoint/index.d.ts

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

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

@@ -0,0 +1,4 @@
+export * from './persisted';
+export * from './endpoint';
+export * from './cron-job';
+export * from './relational-database';

package/dist/tree/built-in/built-in-base-entities/init.d.ts

@@ -0,0 +1,4 @@
+import { ProjectState } from '../../state/project';
+import { BuiltInBaseEntityState } from '../../state/built-in-base-entity/built-in-base-entity';
+
+export declare function initAllBuiltInBaseEntities(project: ProjectState): BuiltInBaseEntityState[];

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

@@ -0,0 +1,23 @@
+import { BaseEntityNames, EntityType, EntityVersion, IBuiltInBaseEntity, IBuiltInBaseEntityTransfer } from '../../../../definitions';
+import { BuiltInBaseEntityState } from '../../../state/built-in-base-entity';
+import { PrimitiveEntityState, ProjectState, PropertyState } from '../../../state';
+import { ActionDescriptorState } from '../../../state/action-descriptor';
+import { EntityError } from '../../../state/error';
+
+export declare class PersistedEntity extends BuiltInBaseEntityState {
+    initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer;
+    readonly id: BaseEntityNames;
+    readonly version: EntityVersion;
+    readonly name: BaseEntityNames;
+    readonly description: string | null;
+    readonly type: EntityType.BuiltInBaseEntity;
+    readonly abstract: boolean;
+    readonly static: boolean;
+    readonly properties: PropertyState[];
+    readonly methods: ActionDescriptorState[];
+    readonly abstractMethods: ActionDescriptorState[];
+    readonly extends: BuiltInBaseEntityState | PrimitiveEntityState | null;
+    errors: EntityError[];
+    project: ProjectState;
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/built-in-base-entities/persisted/index.d.ts

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

package/dist/tree/built-in/built-in-base-entities/relational-database/entity.d.ts

@@ -0,0 +1,23 @@
+import { BaseEntityNames, EntityType, EntityVersion, IBuiltInBaseEntity, IBuiltInBaseEntityTransfer } from '../../../../definitions';
+import { BuiltInBaseEntityState } from '../../../state/built-in-base-entity';
+import { PrimitiveEntityState, ProjectState, PropertyState } from '../../../state';
+import { ActionDescriptorState } from '../../../state/action-descriptor';
+import { EntityError } from '../../../state/error';
+
+export declare class RelationalDatabaseEntity extends BuiltInBaseEntityState {
+    initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer;
+    readonly id: BaseEntityNames;
+    readonly version: EntityVersion;
+    readonly name: BaseEntityNames;
+    readonly description: string | null;
+    readonly type: EntityType.BuiltInBaseEntity;
+    readonly abstract: boolean;
+    readonly static: boolean;
+    readonly properties: PropertyState[];
+    readonly methods: ActionDescriptorState[];
+    readonly abstractMethods: ActionDescriptorState[];
+    readonly extends: BuiltInBaseEntityState | PrimitiveEntityState | null;
+    errors: EntityError[];
+    project: ProjectState;
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/built-in-base-entities/relational-database/index.d.ts

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

package/dist/tree/built-in/index.d.ts

@@ -0,0 +1,3 @@
+export * from './built-in-base-entities';
+export * from './operations';
+export * from './primitive-entities';

package/dist/tree/built-in/operations/definition-entity/index.d.ts

@@ -0,0 +1 @@
+export * from './validate-data';

package/dist/tree/built-in/operations/definition-entity/validate-data.d.ts

@@ -0,0 +1,17 @@
+import { ActionDescriptorState, DefinitionEntityState, DataTypeState, InputMapState, OperationState, OutputMapState, ProjectState } from '../../../state';
+import { IChangeSet, ChangeSet } from '../../../state/change-set/change-set';
+
+export declare class ValidateDataOperation extends ActionDescriptorState {
+    readonly autoexecutable = true;
+    constructor(parentProjectState: ProjectState);
+    getEntityToMatchInputMap(operation: OperationState): InputMapState | null;
+    getDataToValidateInputMap(operation: OperationState): InputMapState | null;
+    getOutputDataOutputMap(operation: OperationState): OutputMapState | null;
+    getEntityToMatch(entityToMatchInputMap: InputMapState, changeSet?: ChangeSet | null): DefinitionEntityState | null;
+    syncOperationInstance(operation: OperationState, changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    syncEntityToMatchInputMapDataType(inputMap: InputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    syncDataToValidateInputMapDataType(inputMap: InputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    syncOutputDataOutputMapDataType(outputMap: OutputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    inferInputMapDataType(inputMap: InputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    inferOutputMapDataType(outputMap: OutputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+}

package/dist/tree/built-in/operations/execution/index.d.ts

@@ -0,0 +1 @@
+export * from './wait';

package/dist/tree/built-in/operations/execution/wait.d.ts

@@ -0,0 +1,18 @@
+import { EntityType } from '../../../../definitions';
+import { ValueDescriptorState } from '../../../state/value-descriptor';
+import { ActionDescriptorState } from '../../../state/action-descriptor';
+import { DataTypeState, ProjectState } from '../../../state';
+
+export declare class WaitOperation extends ActionDescriptorState {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string | null;
+    readonly version: string;
+    readonly autoexecutable = false;
+    readonly type: EntityType.ActionDescriptor;
+    readonly inputs: ValueDescriptorState[];
+    readonly dataType: DataTypeState | null;
+    readonly error: ValueDescriptorState | null;
+    project: ProjectState;
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/operations/http-request/http-request.d.ts

@@ -0,0 +1,6 @@
+import { ActionDescriptorState } from '../../../state/action-descriptor';
+import { ProjectState } from '../../../state';
+
+export declare class HttpRequestOperation extends ActionDescriptorState {
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/operations/http-request/index.d.ts

@@ -0,0 +1 @@
+export * from './http-request';

package/dist/tree/built-in/operations/index.d.ts

@@ -0,0 +1 @@
+export * from './execution';

package/dist/tree/built-in/operations/init.d.ts

@@ -0,0 +1,4 @@
+import { ProjectState } from '../../state/project';
+import { ActionDescriptorState } from '../../state/action-descriptor/action-descriptor';
+
+export declare function initAllOperationsActionDescriptors(project: ProjectState): ActionDescriptorState[];

package/dist/tree/built-in/operations/list/append.d.ts

@@ -0,0 +1,5 @@
+import { ActionDescriptorState, ProjectState } from '../../../state';
+
+export declare class AppendToListOperation extends ActionDescriptorState {
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/operations/list/get-last.d.ts

@@ -0,0 +1,5 @@
+import { ActionDescriptorState, ProjectState } from '../../../state';
+
+export declare class GetLastInListOperation extends ActionDescriptorState {
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/operations/list/index.d.ts

@@ -0,0 +1,4 @@
+export * from './join-lists';
+export * from './split-list';
+export * from './get-last';
+export * from './append';

package/dist/tree/built-in/operations/list/join-lists.d.ts

@@ -0,0 +1,5 @@
+import { ActionDescriptorState, ProjectState } from '../../../state';
+
+export declare class JoinListOperation extends ActionDescriptorState {
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/operations/list/split-list.d.ts

@@ -0,0 +1,5 @@
+import { ActionDescriptorState, ProjectState } from '../../../state';
+
+export declare class SplitListOperation extends ActionDescriptorState {
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/operations/number/index.d.ts

@@ -0,0 +1 @@
+export * from './number-addition';

package/dist/tree/built-in/operations/number/number-addition.d.ts

@@ -0,0 +1,5 @@
+import { ActionDescriptorState, ProjectState } from '../../../state';
+
+export declare class NumberAdditionOperation extends ActionDescriptorState {
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/operations/string/index.d.ts

@@ -0,0 +1 @@
+export * from './join-strings';

package/dist/tree/built-in/operations/string/join-strings.d.ts

@@ -0,0 +1,5 @@
+import { ActionDescriptorState, ProjectState } from '../../../state';
+
+export declare class JoinStringsOperation extends ActionDescriptorState {
+    constructor(parentProjectState: ProjectState);
+}

package/dist/tree/built-in/primitive-entities/index.d.ts

@@ -0,0 +1 @@
+export * from './uuid-validation';

package/dist/tree/built-in/primitive-entities/uuid-validation.d.ts

@@ -0,0 +1,10 @@
+import { LiteralValueType } from '../../../definitions';
+import { IValueValidationResult, EntityWithValueState } from '../../state';
+import { CommonStringValidationErrorCodes } from '../../utils/values-validations';
+
+export declare enum UUIDV4ValidationErrorCodes {
+    UUIDMustBeString = "uuid-must-be-string",
+    UUIDMustBeValidFormat = "uuid-must-be-valid-format",
+    UUIDMustNotContainSpaces = "uuid-must-not-contain-spaces"
+}
+export declare function uuidValueValidation(self: EntityWithValueState, value: LiteralValueType): IValueValidationResult<LiteralValueType, UUIDV4ValidationErrorCodes | CommonStringValidationErrorCodes>;

package/dist/tree/index.d.ts

@@ -0,0 +1,3 @@
+export * from './state';
+export * from './built-in';
+export * from './utils';

package/dist/tree/state/action-descriptor/action-descriptor.d.ts

@@ -0,0 +1,190 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IActionDescriptor, IActionDescriptorGenerationTarget, IActionDescriptorReference, IActionDescriptorShallowTransfer, IActionDescriptorTransfer, ActionDescriptorTypesUnion, EntityVersion, IActionDescriptor_meta, IInternalCallTransfer } from '../../../definitions';
+import { UserManagedBaseState, ChildEntityBaseClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
+import { ProjectState } from '../project/project';
+import { DataTypeState } from '../data-type';
+import { ValueDescriptorState } from '../value-descriptor';
+import { DefinitionEntityState } from '../definition-entity';
+import { PrimitiveEntityState } from '../primitive-entity';
+import { BuiltInBaseEntityState } from '../built-in-base-entity';
+import { EntityError, EntityGenerationError } from '../error';
+import { EntityState, EntityWithLogicScopeState, UserManagedEntityState, VariableState } from '../types';
+import { GenerationExplanationIds } from '../validate';
+import { LoopState } from '../loop';
+import { OperationState } from '../operation';
+import { ConditionState } from '../condition';
+import { InputMapState } from '../input-map';
+import { OutputMapState } from '../output-map';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { InstalledProjectState } from '../installed-project';
+import { FunctionDeclarationState } from '../function-declaration';
+import { GlobalEventState } from '../global-event';
+import { IDynamicValue } from '../../../editor';
+import { InternalCallState } from '../internal-call';
+import { PropertyState } from '../property';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare enum ExecutionTerminationType {
+    Success = "success",
+    ConditionNotMet = "condition-not-met",
+    CaughtError = "caught-error",
+    UnhandledError = "unhandled-error",
+    Break = "break",
+    Continue = "continue",
+    Return = "return"
+}
+export interface IPrimitiveExecutionResult {
+    value: ExecutionTerminationType;
+    result: any;
+    error: any | null;
+}
+export declare class ActionDescriptorState extends UserManagedVersionedState implements IActionDescriptor, UserManagedEntityStateTemplate, UserManagedBaseState, ChildEntityBaseClass {
+    initialData: IActionDescriptorTransfer | IActionDescriptor;
+    readonly id: EntityId;
+    name: string;
+    codeName: string | null;
+    description: string | null;
+    index: number | null;
+    outputName: string | null;
+    outputDescription: string | null;
+    readonly type: EntityType.ActionDescriptor;
+    inputs: ValueDescriptorState[];
+    dataType: DataTypeState | null;
+    error: ValueDescriptorState | null;
+    implementation: ((entity: OperationState, inputs: IDynamicValue[]) => IPrimitiveExecutionResult | Promise<IPrimitiveExecutionResult>) | null;
+    parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState | null;
+    errors: EntityError[];
+    project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, ActionDescriptorState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    autoexecutable: boolean;
+    constructor(initialData: IActionDescriptor | IActionDescriptorTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.ActionDescriptor;
+    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): IActionDescriptorTransfer;
+    static fromGenerationTarget(data: IActionDescriptorGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): ActionDescriptorState;
+    static validateGenerationTarget(data: IActionDescriptorGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IActionDescriptorGenerationTarget;
+    };
+    syncOperationInstance(operation: OperationState, _changeSet: ChangeSet | null): IChangeSet<OperationState>;
+    inferInputMapDataType(inputMap: InputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    inferOutputMapDataType(outputMap: OutputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    validateGeneratedUpdate(data: Partial<IActionDescriptorGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IActionDescriptorGenerationTarget>;
+    };
+    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(): ActionDescriptorState;
+    snapshot(): ActionDescriptorState;
+    /**
+     * 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 {ActionDescriptorState} snapshotInstance
+     * @returns {ActionDescriptorState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: ActionDescriptorState): ActionDescriptorState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ActionDescriptorState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<ActionDescriptorState>>;
+    updateWithShallowTransfer(transfer: IActionDescriptorShallowTransfer, changeSet?: ChangeSet | null): ActionDescriptorState;
+    updateWithGenerationTarget(transfer: Partial<IActionDescriptorGenerationTarget>, changeSet?: ChangeSet | null): ActionDescriptorState;
+    hydrateAncestors(): IChangeSet<ActionDescriptorState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ActionDescriptorState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ActionDescriptorState>;
+    setParent(parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState, changeSet?: ChangeSet | null): ActionDescriptorState;
+    initChildren(changeSet?: ChangeSet | null): ActionDescriptorState;
+    subscribe(): ActionDescriptorState;
+    unsubscribe(): ActionDescriptorState;
+    metaSync(changedData: Partial<IActionDescriptor_meta | IActionDescriptor | IActionDescriptorTransfer | IActionDescriptorShallowTransfer>, changeSet?: ChangeSet | null): ActionDescriptorState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IActionDescriptorShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<ActionDescriptorState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IActionDescriptor_meta;
+    toJSON(seenEntities?: Set<EntityId>): IActionDescriptorTransfer | IActionDescriptorReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IActionDescriptorTransfer | IActionDescriptorReference;
+    toReference(options?: IEntityRecursionOptions): IActionDescriptorReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IActionDescriptorShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IActionDescriptorGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    implementAsGlobalEvent(changeSet?: ChangeSet | null, parent?: ProjectState, newEntityId?: EntityId): GlobalEventState;
+    implementAsFunctionDeclaration(changeSet?: ChangeSet | null, parent?: ProjectState | InstalledProjectState | DefinitionEntityState | LoopState, newEntityId?: EntityId): FunctionDeclarationState;
+    implementAsLoop(changeSet?: ChangeSet | null, parent?: EntityWithLogicScopeState, newEntityId?: EntityId): LoopState;
+    implementAsOperation(changeSet?: ChangeSet | null, parent?: EntityWithLogicScopeState, newEntityId?: string): OperationState;
+    implementAsCondition(changeSet?: ChangeSet | null, parent?: EntityWithLogicScopeState, newEntityId?: EntityId): ConditionState;
+    clearErrors(): ActionDescriptorState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(changeSet?: ChangeSet | null, parent?: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState | null, newId?: string | null, subscribe?: boolean): ActionDescriptorState;
+    addInput(argument: ValueDescriptorState, changeSet?: ChangeSet | null): ActionDescriptorState;
+    removeInput(argument: ValueDescriptorState, changeSet?: ChangeSet | null): ActionDescriptorState;
+    setError(error: ValueDescriptorState | null, changeSet?: ChangeSet | null): ActionDescriptorState;
+    setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): ActionDescriptorState;
+    removeDataType(changeSet?: ChangeSet | null): ActionDescriptorState;
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+    createInternalCall(changeSet: (ChangeSet | null) | undefined, parent: VariableState, overrides?: Partial<IInternalCallTransfer>): InternalCallState;
+    getUniqueOutputProperties(): PropertyState[];
+}
+export type ActionDescriptorPayloadUnion = ActionDescriptorState | ActionDescriptorTypesUnion;

package/dist/tree/state/action-descriptor/index.d.ts

@@ -0,0 +1,3 @@
+export * from './action-descriptor';
+import * as actionDescriptorValidation from './validation/logic-validation';
+export { actionDescriptorValidation };

package/dist/tree/state/action-descriptor/validation/logic-validation.d.ts

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