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

package/dist/tree/state/definition-entity/validation/validation-schema.d.ts

@@ -0,0 +1,472 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getDefinitionEntityTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.DefinitionEntity>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DefinitionEntity;
+}, {
+    type: EntityType.DefinitionEntity;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getDefinitionEntityReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.DefinitionEntity>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.DefinitionEntity;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.DefinitionEntity;
+    entityId: string;
+}>;
+export declare function getDefinitionEntityBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.DefinitionEntity>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    static: z.ZodBoolean;
+    abstract: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DefinitionEntity;
+    id: string;
+    name: string;
+    description: string | null;
+    static: boolean;
+    abstract: boolean;
+}, {
+    type: EntityType.DefinitionEntity;
+    id: string;
+    name: string;
+    description: string | null;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getDefinitionEntityMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.DefinitionEntity>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    static: z.ZodBoolean;
+    abstract: z.ZodBoolean;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DefinitionEntity;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    static: boolean;
+    abstract: boolean;
+}, {
+    type: EntityType.DefinitionEntity;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getDefinitionEntityGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.DefinitionEntity>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    static: z.ZodBoolean;
+    abstract: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DefinitionEntity;
+    id: string;
+    name: string;
+    description: string | null;
+    static: boolean;
+    abstract: boolean;
+}, {
+    type: EntityType.DefinitionEntity;
+    id: string;
+    name: string;
+    description: string | null;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getDefinitionEntityParentReferenceSchema(): z.ZodUnion<[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;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.DataType>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.DataType;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.DataType;
+    entityId: string;
+}>]>;
+export declare function checkExtendsBaseEntityReferencesSchema(): z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.DefinitionEntity>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DefinitionEntity;
+}, {
+    type: EntityType.DefinitionEntity;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.BuiltInBaseEntity;
+}, {
+    type: EntityType.BuiltInBaseEntity;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+export declare function getDefinitionEntityImplementsReferencesSchema(): z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.DefinitionEntity>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DefinitionEntity;
+}, {
+    type: EntityType.DefinitionEntity;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.BuiltInBaseEntity;
+}, {
+    type: EntityType.BuiltInBaseEntity;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+export declare function getDefinitionEntityNestedEntitiesSchema(): 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.DefinitionEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DefinitionEntity;
+    }, {
+        type: EntityType.DefinitionEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.BuiltInBaseEntity;
+    }, {
+        type: EntityType.BuiltInBaseEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+    implements: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.DefinitionEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DefinitionEntity;
+    }, {
+        type: EntityType.DefinitionEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.BuiltInBaseEntity;
+    }, {
+        type: EntityType.BuiltInBaseEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+    parent: z.ZodUnion<[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;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.DataType>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.DataType;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.DataType;
+        entityId: string;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    } | {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.DataType;
+        entityId: string;
+    };
+    implements: (Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    extends: (Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+}, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    } | {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.DataType;
+        entityId: string;
+    };
+    implements: (Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    extends: (Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+}>;
+export declare function getDefinitionEntitySchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.DefinitionEntity>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    static: z.ZodBoolean;
+    abstract: z.ZodBoolean;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+} & {
+    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.DefinitionEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DefinitionEntity;
+    }, {
+        type: EntityType.DefinitionEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.BuiltInBaseEntity;
+    }, {
+        type: EntityType.BuiltInBaseEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+    implements: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.DefinitionEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DefinitionEntity;
+    }, {
+        type: EntityType.DefinitionEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.BuiltInBaseEntity;
+    }, {
+        type: EntityType.BuiltInBaseEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+    parent: z.ZodUnion<[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;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.DataType>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.DataType;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.DataType;
+        entityId: string;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    } | {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.DataType;
+        entityId: string;
+    };
+    type: EntityType.DefinitionEntity;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    implements: (Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    extends: (Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    x: number;
+    y: number;
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+    static: boolean;
+    abstract: boolean;
+}, {
+    parent: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Project;
+        entityId: string;
+    } | {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.DataType;
+        entityId: string;
+    };
+    type: EntityType.DefinitionEntity;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    implements: (Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    extends: (Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    x: number;
+    y: number;
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+    static: boolean;
+    abstract: boolean;
+}>;

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

@@ -0,0 +1,201 @@
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+import { EntityState } from './types';
+
+export declare enum EntityErrorSeverity {
+    Error = "error",
+    Warning = "warning"
+}
+export declare enum SharedEntityErrorCode {
+    InvalidObjectStructure = "invalid-object-structure",
+    NameNotUniqueInScope = "name-not-unique-in-scope",
+    NameAsResolvedCodeNameNotUniqueInScope = "name-as-resolved-code-name-not-unique-in-scope",
+    NameMustStartWithLetterOrUnderscore = "name-must-start-with-letter-or-underscore",
+    NameCanOnlyContainLettersNumbersUnderscoreAndSpaces = "name-can-only-contain-letters-numbers-underscore-and-spaces",
+    NameIsForbiddenKeyword = "name-is-forbidden-keyword",
+    EmptyName = "empty-name",
+    MissingCaller = "missing-caller",
+    PropertyOverwritesOtherSiblingWithSameName = "property-overwrites-other-sibling-with-same-name",
+    PropertyOverwritesOtherSiblingWithSameImplementation = "property-overwrites-other-sibling-with-same-name",
+    PropertyOverwritesOtherImplementedEntitysPropertyWithSameName = "property-overwrites-other-implemented-entitys-property-with-same-name",
+    PropertyOverwritesOtherImplementedEntitysPropertyWithSameImplementation = "property-overwrites-other-implemented-entitys-property-with-same-name",
+    PropertyOverwritesOtherExtendedEntitysPropertyWithSameImplementation = "property-overwrites-other-extended-entitys-property-with-same-name",
+    PropertyOverwritesOtherExtendedEntitysPropertyWithSameName = "property-overwrites-other-extended-entitys-property-with-same-name",
+    PropertyOverwritesBasePropertyWithSameName = "property-overwrites-base-property-with-same-name",
+    PropertyOverwritesBasePropertyWithSameImplementation = "property-overwrites-base-property-with-same-name",
+    MethodOverwritesOtherSiblingWithSameName = "method-overwrites-other-sibling-with-same-name",
+    MethodOverwritesOtherSiblingWithSameImplementation = "method-overwrites-other-sibling-with-same-name",
+    MethodOverwritesOtherImplementedEntitysMethodWithSameName = "method-overwrites-other-implemented-entitys-method-with-same-name",
+    MethodOverwritesOtherImplementedEntitysMethodWithSameImplementation = "method-overwrites-other-implemented-entitys-method-with-same-name",
+    MethodOverwritesOtherExtendedEntitysMethodWithSameImplementation = "method-overwrites-other-extended-entitys-method-with-same-name",
+    MethodOverwritesOtherExtendedEntitysMethodWithSameName = "method-overwrites-other-extended-entitys-method-with-same-name",
+    MethodOverwritesBaseMethodWithSameName = "method-overwrites-base-method-with-same-name",
+    MethodOverwritesBaseMethodWithSameImplementation = "method-overwrites-base-method-with-same-name",
+    LoopBodyFunctionOverwrite = "loop-body-function-overwrite",
+    NoOverlapWithImplementedSignature = "no-overlap-with-implemented-signature",
+    ReaderWriterIncompatibleDataType = "reader-writer-incompatible-data-type",
+    UnreachableEntity = "unreachable-entity",
+    InternalCallParentMissingDataType = "internal-call-parent-missing-data-type",
+    InternalCallParentDeclarationEntityInvalidType = "internal-call-parent-declaration-entity-invalid-type",
+    InternalCallDeclarationNotFoundInParentDatatypeEntity = "internal-call-declaration-not-found-in-parent-datatype-entity",
+    InternalCallDeclarationNotFound = "internal-call-declaration-not-found",
+    InternalCallDeclarationIsInvalidType = "internal-call-declaration-is-invalid-type",
+    InternalCallDeclarationNotInParentDatatypeEntity = "internal-call-declaration-not-in-parent-datatype-entity",
+    GlobalVariableDeclarationCannotCatchError = "global-variable-declaration-cannot-catch-error",
+    GlobalVariableDeclarationCannotCallOnError = "global-variable-declaration-cannot-call-on-error",
+    GlobalVariableDeclarationCannotBeCalled = "global-variable-declaration-cannot-be-called"
+}
+export declare enum EntityGenerationErrorCode {
+    RootReference = "root-reference",
+    InvalidUUIDStringFormat = "invalid-uuid-string-format",
+    ReferencedEntityNotFound = "referenced-entity-not-found",
+    ReferencedValueReaderEntityNotFound = "referenced--value-reader-entity-not-found",
+    InvalidValueWriterReference = "invalid-value-writer-reference",
+    EntityIdNotUnique = "entity-id-not-unique",
+    BuiltInEntityGenerated = "built-in-entity-generated",
+    BuiltInEntityUpdated = "built-in-entity-updated",
+    BuiltInEntityDeleted = "built-in-entity-deleted",
+    UnknownEntityType = "unknown-entity-type",
+    MissingTypeProperty = "missing-type-property",
+    MissingIdProperty = "missing-id-property",
+    BuiltInEntityParent = "built-in-entity-parent",
+    InvalidBuiltInEntityReference = "invalid-built-in-entity-reference",
+    RecommendedImplementAbstractEntityAction = "recommended-implement-abstract-entity-action",
+    RecommendedImplementOperationAction = "recommended-implement-operation-action",
+    RecommendedImplementFunctionCallAction = "recommended-implement-function-call-action",
+    RecommendedImplementVariableDeclarationAction = "recommended-implement-variable-declaration-action",
+    RecommendedImplementVariableInstanceAction = "recommended-implement-variable-instance-action",
+    RecommendedImplementInternalCallAction = "recommended-implement-internal-call-action",
+    RecommendedImplementConditionAction = "recommended-implement-condition-action",
+    InvalidReferenceObjectStructure = "invalid-reference-object-structure",
+    ContainsSingleButShouldBeReferenceList = "contains-single-but-should-be-reference-list",
+    ContainsListButShouldReferenceSingle = "contains-list-but-should-reference-single",
+    InvalidParentReference = "invalid-parent-reference",
+    InvalidImplementsReference = "invalid-implements-reference",
+    InvalidExtendsReference = "invalid-extends-reference",
+    InvalidGenerationActionPayload = "invalid-generation-action-payload",
+    InvalidReference = "invalid-reference",
+    InvalidInternalCallParentRelation = "invalid-internal-call-parent-relation",
+    InvalidUpdateEntityOperation = "invalid-update-entity-operation",
+    InvalidBuiltInActionDescriptorForInternalCallReference = "invalid-built-in-action-descriptor-for-internal-call-reference",
+    NewEntityWouldOverriteExisting = "new-entity-would-overrite-existing",
+    InvalidDownstreamPropertyOverride = "invalid-downstream-property-override",
+    UnrecognizedProperty = "unrecognized-property",
+    SelfReference = "self-reference",
+    DuplicateReference = "duplicate-reference",
+    CallerWithIncompatibleScope = "caller-with-incompatible-scope",
+    InvalidFunctionDeclarationForFunctionCall = "invalid-function-declaration-for-function-call",
+    InvalidInputMapDeclaration = "invalid-input-map-declaration",
+    InvalidActionDescriptorForOperation = "invalid-action-descriptor-for-operation",
+    InvalidActionDescriptorForCondition = "invalid-action-descriptor-for-condition",
+    InvalidActionDescriptorForLoop = "invalid-action-descriptor-for-loop",
+    InvalidInmutablePropertyOverride = "invalid-inmutable-property-override",
+    OutputOverwrite = "output-overwrite",
+    InputOverwrite = "input-overwrite",
+    IncompatibleScope = "incompatible-scope",
+    InvalidParentUpdate = "invalid-parent-update",
+    NonInteractiveEntityReferenced = "non-interactive-entity-referenced",
+    InvalidParentRelationType = "invalid-parent-relation-type",
+    CannotImplementExternalIntegrationConnectionDirectly = "cannot-implement-external-integration-connection-directly",
+    IncompatibleReaderAndWriter = "incompatible-reader-and-writer",
+    PersistedEntityWithGivenNameNotFoundWhenEnrichingSQLQueryTableAgainstProjectState = "persisted-entity-with-given-name-not-found-when-enriching-sql-query-table-against-project-state",
+    PropertyWithGivenNameNotFoundWhenEnrichingSQLQueryColumnAgainstProjectState = "property-with-given-name-not-found-when-enriching-sql-query-column-against-project-state",
+    GenericSQLQueryEnrichmentError = "generic-sql-query-enrichment-error"
+}
+export declare enum EntityInstanceErrorCode {
+    NoPrimaryKeyProperty = "no-primary-key-property",
+    MissingEnumOptions = "missing-enum-options",
+    ScopeWithoutLogic = "scope-without-logic",
+    EmptyGroupCondition = "empty-group-condition",
+    AbstractEntityImplements = "abstract-entity-implements",
+    ImplementsIncompatibleEntities = "implements-incompatible-entities",
+    ExtendsIncompatibleEntities = "extends-incompatible-entities",
+    NonAbstractExtendingAbstractEntity = "non-abstract-extending-abstract-entity",
+    AbstractExtendingNonAbstractEntity = "abstract-extending-non-abstract-entity",
+    NonStaticExtendingStaticEntity = "non-static-extending-static-entity",
+    StaticExtendingNonStaticEntity = "static-extending-non-static-entity",
+    StaticImplementingNonStaticEntity = "static-implementing-non-static-entity",
+    NonStaticImplementingStaticEntity = "non-static-implementing-static-entity",
+    ImplementingNonAbstractEntity = "implementing-non-abstract-entity",
+    ExtendingNonInteractiveEntity = "extending-non-interactive-entity",
+    AbstractEntityWithNonAbstractMethods = "abstract-entity-with-non-abstract-methods",
+    AbstractEntityWithNonAbstractProperties = "abstract-entity-with-non-abstract-properties",
+    StaticEntityWithNonStaticProperties = "static-entity-with-non-static-properties",
+    NonStaticPropertyInStaticEntity = "non-static-property-in-static-entity",
+    AbstractPropertyInNonAbstractEntity = "abstract-property-in-non-abstract-entity",
+    AbstractMethodInNonAbstractEntity = "abstract-method-in-non-abstract-entity",
+    IncorrectEntityImplementation = "incorrect-entity-implementation",
+    IncorrectMethodImplementation = "incorrect-method-implementation",
+    IncorrectPropertyImplementation = "incorrect-property-implementation",
+    PropertyImplementsNonAbstact = "property-implements-non-abstract",
+    NonStaticPropertyImplementsStatic = "non-static-property-implements-static",
+    StaticPropertyImplementsNonStatic = "static-property-implements-non-static",
+    PropertyImplementsIncompatibleType = "property-implements-incompatible-type",
+    MissingPropertyImplementation = "missing-property-implementation",
+    MissingMethodImplementation = "missing-method-implementation",
+    NoProperties = "no-properties",
+    ReadingFromIncompatibleType = "reading-from-incompatible-type",
+    WritingToIncompatibleType = "writing-to-incompatible-type",
+    InvalidPropertiesCombination = "invalid-properties-combination",
+    DisconnectedCallableEntity = "disconnected-callable-entity",
+    VariableReadsValueAndInternalCall = "variable-reads-value-and-internal-call",
+    VariableWritesValuesAndInternalCall = "variable-writes-values-and-internal-call",
+    VariableHasInputsAndInternalCall = "variable-has-inputs-and-internal-calls",
+    VariableHasOutputsAndInternalCall = "variable-has-outputs-and-internal-call",
+    VariableIsCalledAndHasInternalCall = "variable-is-called-and-has-internal-call",
+    VariableCallsOthersAndHasInternalCall = "variable-calls-others-and-has-internal-call",
+    MissingRequiredValue = "missing-required-value",
+    LackingReturnStatementOnSomeBranches = "lacking-return-statement-on-some-branches",
+    LastCalledEntityMustBeReturnEntity = "last-called-entity-must-be-return-entity",
+    ValueReadingOverridesConstantProperty = "value-reading-overrides-constant-property",
+    DefaultValueOverridesConstantProperty = "default-value-overrides-constant-property",
+    ValueReadingOverridesConstantVariable = "value-reading-overrides-constant-variable",
+    DefaultValueOverridesConstantVariable = "default-value-overrides-constant-variable",
+    CalledBeforeDeclaration = "called-before-declaration",
+    CalledInParallelBranchToDeclaration = "called-in-parallel-branch-to-declaration",
+    HigherScopeThanDeclaration = "higher-scope-than-declaration",
+    ParentScopeRequiresReturnCurrentCatchesErrorWithNoCalls = "parent-scope-requires-return-current-catches-error-with-no-calls",
+    ParentScopeRequiresReturnCurrentHasNoSuccessCalls = "parent-scope-requires-return-current-has-no-success-calls"
+}
+export type EntityErrorCode = SharedEntityErrorCode | EntityGenerationErrorCode | EntityInstanceErrorCode;
+export interface IEntityGenerationError {
+    id: string;
+    message: string;
+    severity: EntityErrorSeverity;
+    code: SharedEntityErrorCode | EntityGenerationErrorCode;
+}
+export interface IEntityError<TCode = SharedEntityErrorCode | EntityInstanceErrorCode> {
+    id: string;
+    message: string;
+    severity: EntityErrorSeverity;
+    code: TCode;
+    entity: EntityState;
+    firstRelationship?: EntityState;
+    secondRelationship?: EntityState;
+}
+export declare class EntityGenerationError implements IEntityGenerationError {
+    id: string;
+    message: string;
+    severity: EntityErrorSeverity;
+    code: SharedEntityErrorCode | EntityGenerationErrorCode;
+    constructor(error: IEntityGenerationError);
+    toEntityError(entity: EntityState): EntityError | null;
+}
+export declare class EntityError<TCode = SharedEntityErrorCode | EntityInstanceErrorCode> implements IEntityError<TCode> {
+    id: string;
+    message: string;
+    severity: EntityErrorSeverity;
+    code: TCode;
+    entity: EntityState;
+    firstRelationship?: EntityState;
+    secondRelationship?: EntityState;
+    constructor(error: IEntityError<TCode>);
+    clone(): EntityError<TCode>;
+}
+export declare function filterOutDuplicateErrorsAsync(errors: (EntityGenerationError | EntityError)[], options?: YieldOptions): Promise<EntityGenerationError[] | EntityError[]>;
+export declare function filterOutDuplicateErrors(errors: (EntityGenerationError | EntityError)[]): EntityGenerationError[] | EntityError[];
+export declare function createEntityError(error: IEntityError): {
+    new: boolean;
+    error: EntityError;
+};
+export declare function mergeEntityErrorsList(oldErrors: EntityError[], newErrors: EntityError[]): EntityError[];
+export declare function updateErrorsList(oldErrors: EntityError[], newErrors: EntityError[]): EntityError[];