@elyx-code/project-logic-tree 0.0.1

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

@@ -0,0 +1,82 @@
+import { BaseEntityNames, BuiltInBaseEntityTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IBuiltInBaseEntity, IBuiltInBaseEntityGenerationTarget, IBuiltInBaseEntityReference, IBuiltInBaseEntityShallowTransfer, IBuiltInBaseEntityTransfer } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseState } from '../base';
+import { PropertyState } from '../property';
+import { ProjectState } from '../project/project';
+import { PrimitiveEntityState } from '../primitive-entity';
+import { FunctionDeclarationState } from '../function-declaration';
+import { ActionDescriptorState } from '../action-descriptor';
+import { EntityError, EntityGenerationError } from '../../state/error';
+import { EntityState } from '../types';
+import { CustomEntityState } from '../custom-entity';
+
+export declare class BuiltInBaseEntityState implements BaseState, IBuiltInBaseEntity {
+    initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer;
+    readonly id: BaseEntityNames;
+    readonly version: EntityVersion;
+    readonly name: BaseEntityNames;
+    readonly description: string | null;
+    readonly type: EntityType.BuiltInBaseEntity;
+    readonly abstract: boolean;
+    readonly static: boolean;
+    readonly properties: PropertyState[];
+    readonly methods: FunctionDeclarationState[];
+    readonly abstractMethods: ActionDescriptorState[];
+    readonly extends: (BuiltInBaseEntityState | PrimitiveEntityState)[];
+    readonly interactive: boolean;
+    errors: EntityError[];
+    project: ProjectState;
+    constructor(initialEntityData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer, parentProjectState: ProjectState);
+    get extendedProperties(): PropertyState[];
+    subscribe(): BuiltInBaseEntityState;
+    unsubscribe(): BuiltInBaseEntityState;
+    load(): Promise<BuiltInBaseEntityState>;
+    remove(_?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities: _ }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: BuiltInBaseEntityState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IBuiltInBaseEntityTransfer;
+    toReference(): IBuiltInBaseEntityReference;
+    toShallowJSON(): IBuiltInBaseEntityShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IBuiltInBaseEntityGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): BuiltInBaseEntityState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IBuiltInBaseEntityTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(): BuiltInBaseEntityState;
+    implement(newEntityName: string, newId?: string): {
+        errors: [];
+        implemented: CustomEntityState;
+        entitiesChanges: {
+            new: EntityState[];
+            updated: EntityState[];
+            deleted: EntityState[];
+        };
+    } | {
+        errors: [EntityGenerationError, ...EntityGenerationError[]];
+        implemented: null;
+        entitiesChanges: {
+            new: [];
+            updated: [];
+            deleted: [];
+        };
+    };
+}
+export type BuiltInBaseEntityPayloadUnion = BuiltInBaseEntityState | BuiltInBaseEntityTypesUnion;

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

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

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

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

package/dist/tree/state/built-in-base-entity/logic-validation.d.ts

@@ -0,0 +1,4 @@
+import { EntityError } from '../error';
+import { BuiltInBaseEntityState } from './built-in-base-entity';
+
+export declare function validate(self: BuiltInBaseEntityState): EntityError[];

package/dist/tree/state/built-in-base-entity/validation-schema.d.ts

@@ -0,0 +1,256 @@
+import { BaseEntityNames, EntityType } from '../../../../../../../../../src/definitions';
+import { z } from 'zod';
+
+export declare function getBuiltInBaseEntityNamesSchema(): z.ZodEnum<[BaseEntityNames.CRON_JOB, BaseEntityNames.EXECUTION, BaseEntityNames.HTTP_ENDPOINT, BaseEntityNames.PERSISTED_ENTITY, BaseEntityNames.RELATIONAL_DATABASE]>;
+export declare function getBuiltInBaseEntityTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.BuiltInBaseEntity;
+}, {
+    type: EntityType.BuiltInBaseEntity;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getBuiltInBaseEntityReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.GenericReference;
+    entityType: EntityType.BuiltInBaseEntity;
+    entityId: string;
+}, {
+    id: string;
+    type: EntityType.GenericReference;
+    entityType: EntityType.BuiltInBaseEntity;
+    entityId: string;
+}>;
+export declare function getBuiltInBaseEntityBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+    type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    name: z.ZodEnum<[BaseEntityNames.CRON_JOB, BaseEntityNames.EXECUTION, BaseEntityNames.HTTP_ENDPOINT, BaseEntityNames.PERSISTED_ENTITY, BaseEntityNames.RELATIONAL_DATABASE]>;
+    description: z.ZodNullable<z.ZodString>;
+    abstract: z.ZodBoolean;
+    static: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.BuiltInBaseEntity;
+    name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
+    description: string | null;
+    version: number;
+    static: boolean;
+    abstract: boolean;
+}, {
+    id: string;
+    type: EntityType.BuiltInBaseEntity;
+    name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
+    description: string | null;
+    version: number;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getBuiltInBaseEntityMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+    type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    name: z.ZodEnum<[BaseEntityNames.CRON_JOB, BaseEntityNames.EXECUTION, BaseEntityNames.HTTP_ENDPOINT, BaseEntityNames.PERSISTED_ENTITY, BaseEntityNames.RELATIONAL_DATABASE]>;
+    description: z.ZodNullable<z.ZodString>;
+    abstract: z.ZodBoolean;
+    static: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.BuiltInBaseEntity;
+    name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
+    description: string | null;
+    version: number;
+    static: boolean;
+    abstract: boolean;
+}, {
+    id: string;
+    type: EntityType.BuiltInBaseEntity;
+    name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
+    description: string | null;
+    version: number;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getBuiltInBaseEntityGenerationTargetSchema(): z.ZodObject<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+    type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    name: z.ZodEnum<[BaseEntityNames.CRON_JOB, BaseEntityNames.EXECUTION, BaseEntityNames.HTTP_ENDPOINT, BaseEntityNames.PERSISTED_ENTITY, BaseEntityNames.RELATIONAL_DATABASE]>;
+    description: z.ZodNullable<z.ZodString>;
+    abstract: z.ZodBoolean;
+    static: z.ZodBoolean;
+}, {}>, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.BuiltInBaseEntity;
+    name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
+    description: string | null;
+    version: number;
+    static: boolean;
+    abstract: boolean;
+}, {
+    id: string;
+    type: EntityType.BuiltInBaseEntity;
+    name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
+    description: string | null;
+    version: number;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getBuiltInBaseEntityNestedEntitiesSchema(): z.ZodObject<{
+    properties: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Property>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Property;
+    }, {
+        type: EntityType.Property;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    methods: 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">;
+    abstractMethods: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ActionDescriptor;
+    }, {
+        type: EntityType.ActionDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    extends: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.BuiltInBaseEntity;
+    }, {
+        type: EntityType.BuiltInBaseEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.PrimitiveEntity;
+    }, {
+        type: EntityType.PrimitiveEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    extends: (Record<string, any> | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.BuiltInBaseEntity;
+    })[];
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+}, {
+    extends: (Record<string, any> | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.BuiltInBaseEntity;
+    })[];
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+}>;
+export declare function getBuiltInBaseEntitySchema(): z.ZodObject<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+    type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    name: z.ZodEnum<[BaseEntityNames.CRON_JOB, BaseEntityNames.EXECUTION, BaseEntityNames.HTTP_ENDPOINT, BaseEntityNames.PERSISTED_ENTITY, BaseEntityNames.RELATIONAL_DATABASE]>;
+    description: z.ZodNullable<z.ZodString>;
+    abstract: z.ZodBoolean;
+    static: z.ZodBoolean;
+}, {
+    properties: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Property>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Property;
+    }, {
+        type: EntityType.Property;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    methods: 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">;
+    abstractMethods: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ActionDescriptor;
+    }, {
+        type: EntityType.ActionDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    extends: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.BuiltInBaseEntity;
+    }, {
+        type: EntityType.BuiltInBaseEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.PrimitiveEntity;
+    }, {
+        type: EntityType.PrimitiveEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+}>, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.BuiltInBaseEntity;
+    name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
+    description: string | null;
+    extends: (Record<string, any> | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.BuiltInBaseEntity;
+    })[];
+    version: number;
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+    static: boolean;
+    abstract: boolean;
+}, {
+    id: string;
+    type: EntityType.BuiltInBaseEntity;
+    name: BaseEntityNames.HTTP_ENDPOINT | BaseEntityNames.RELATIONAL_DATABASE | BaseEntityNames.PERSISTED_ENTITY | BaseEntityNames.CRON_JOB | BaseEntityNames.EXECUTION;
+    description: string | null;
+    extends: (Record<string, any> | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.BuiltInBaseEntity;
+    })[];
+    version: number;
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+    static: boolean;
+    abstract: boolean;
+}>;

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

@@ -0,0 +1,105 @@
+import { EntityId, EntityType, EntityVersion, ICondition, IConditionTransfer, IConditionReference, IConditionShallowTransfer, ElementShallowTransfer, IConditionGenerationTarget, ElementGenerationTarget, ConditionTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState } from '../types';
+import { ActionInputMapState } from '../input-map';
+import { ProjectState } from '../project/project';
+import { EntityError, EntityGenerationError } from '../../state/error';
+import { ActionOutputMapState } from '../output-map';
+import { ActionDescriptorState } from '../action-descriptor';
+
+export declare class ConditionState implements ICondition, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+    initialData: ICondition | IConditionTransfer;
+    readonly id: EntityId;
+    version: EntityVersion;
+    x: number;
+    y: number;
+    readonly type: EntityType.Condition;
+    successCalls: CallableEntityState[];
+    errorCalls: CallableEntityState[];
+    declaration: ActionDescriptorState;
+    inputs: ActionInputMapState[];
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    project: ProjectState;
+    errors: EntityError[];
+    parent: EntityWithLogicScopeState | ProjectState;
+    initialized: boolean;
+    constructor(initialConditionData: ICondition | IConditionTransfer, parentProjectState: ProjectState);
+    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 fromGenerationTarget(data: IConditionGenerationTarget, parentProjectState: ProjectState): ConditionState;
+    static validateGenerationTarget(data: IConditionGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IConditionGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IConditionGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IConditionGenerationTarget>;
+    };
+    addSelfToProject(): ConditionState;
+    get calledBy(): CallerEntityState[];
+    removeInput(input: ActionInputMapState): ConditionState;
+    addInput(input: ActionInputMapState): ConditionState;
+    addOutput(_: ActionOutputMapState): ConditionState;
+    removeOutput(_: ActionOutputMapState): ConditionState;
+    addSuccessCaller(caller: PassThroughCallableEntityState): ConditionState;
+    addErrorCaller(caller: PassThroughCallableEntityState): ConditionState;
+    addEntryCaller(caller: EntryPointEntityState): ConditionState;
+    addErrorCall(call: CallableEntityState): ConditionState;
+    addSuccessCall(call: CallableEntityState): ConditionState;
+    removeCall(call: CallableEntityState): ConditionState;
+    removeCaller(caller: CallerEntityState): ConditionState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState): ConditionState;
+    initChildren(): ConditionState;
+    subscribe(): ConditionState;
+    unsubscribe(): ConditionState;
+    sync(data: Partial<ICondition>): ConditionState;
+    load(): Promise<ConditionState>;
+    create(): Promise<ConditionState>;
+    update(_: Partial<ConditionTypesUnion>): Promise<ConditionState>;
+    delete(): Promise<ConditionState>;
+    remove({ ignoreUpstream, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: EntityState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IConditionTransfer;
+    toReference(): IConditionReference;
+    toShallowJSON(): IConditionShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IConditionGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): ConditionState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IConditionTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(_?: EntryPointEntityState): ConditionState;
+}
+export type ConditionPayloadUnion = ConditionTypesUnion | ConditionState;

package/dist/tree/state/condition/index.d.ts

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

package/dist/tree/state/condition/init.d.ts

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

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

@@ -0,0 +1,4 @@
+import { EntityError } from '../../error';
+import { ConditionState } from '../condition';
+
+export declare function validate(self: ConditionState): EntityError[];