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

package/dist/tree/state/data-type/validation/validation-schema.d.ts

@@ -0,0 +1,414 @@
+import { DataTypeParentChildRelation, EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getDataTypeTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.DataType>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DataType;
+}, {
+    type: EntityType.DataType;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getDataTypeReferenceSchema(): 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 getDataTypeBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.DataType>;
+    isList: z.ZodNullable<z.ZodBoolean>;
+    asType: z.ZodNullable<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    like: z.ZodNullable<z.ZodBoolean>;
+    implementationChooseOne: z.ZodNullable<z.ZodBoolean>;
+    foreignKeyAllowed: z.ZodNullable<z.ZodBoolean>;
+    staticEntities: z.ZodNullable<z.ZodBoolean>;
+    interactiveEntities: z.ZodNullable<z.ZodBoolean>;
+    actionEntities: z.ZodNullable<z.ZodBoolean>;
+    parentRelationType: z.ZodOptional<z.ZodNullable<z.ZodEnum<[DataTypeParentChildRelation.AndDataTypeGroup, DataTypeParentChildRelation.OrDataTypeGroup]>>>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DataType;
+    id: string;
+    isList: boolean | null;
+    asType: boolean | null;
+    foreignKeyAllowed: boolean | null;
+    interactiveEntities: boolean | null;
+    staticEntities: boolean | null;
+    actionEntities: boolean | null;
+    like: boolean | null;
+    implementationChooseOne: boolean | null;
+    parentRelationType?: DataTypeParentChildRelation | null | undefined;
+    options?: string[] | undefined;
+}, {
+    type: EntityType.DataType;
+    id: string;
+    isList: boolean | null;
+    asType: boolean | null;
+    foreignKeyAllowed: boolean | null;
+    interactiveEntities: boolean | null;
+    staticEntities: boolean | null;
+    actionEntities: boolean | null;
+    like: boolean | null;
+    implementationChooseOne: boolean | null;
+    parentRelationType?: DataTypeParentChildRelation | null | undefined;
+    options?: string[] | undefined;
+}>;
+export declare function getDataTypeMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.DataType>;
+    isList: z.ZodNullable<z.ZodBoolean>;
+    asType: z.ZodNullable<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    like: z.ZodNullable<z.ZodBoolean>;
+    implementationChooseOne: z.ZodNullable<z.ZodBoolean>;
+    foreignKeyAllowed: z.ZodNullable<z.ZodBoolean>;
+    staticEntities: z.ZodNullable<z.ZodBoolean>;
+    interactiveEntities: z.ZodNullable<z.ZodBoolean>;
+    actionEntities: z.ZodNullable<z.ZodBoolean>;
+    parentRelationType: z.ZodOptional<z.ZodNullable<z.ZodEnum<[DataTypeParentChildRelation.AndDataTypeGroup, DataTypeParentChildRelation.OrDataTypeGroup]>>>;
+} & {
+    version: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DataType;
+    id: string;
+    version: string;
+    isList: boolean | null;
+    asType: boolean | null;
+    foreignKeyAllowed: boolean | null;
+    interactiveEntities: boolean | null;
+    staticEntities: boolean | null;
+    actionEntities: boolean | null;
+    like: boolean | null;
+    implementationChooseOne: boolean | null;
+    parentRelationType?: DataTypeParentChildRelation | null | undefined;
+    options?: string[] | undefined;
+}, {
+    type: EntityType.DataType;
+    id: string;
+    version: string;
+    isList: boolean | null;
+    asType: boolean | null;
+    foreignKeyAllowed: boolean | null;
+    interactiveEntities: boolean | null;
+    staticEntities: boolean | null;
+    actionEntities: boolean | null;
+    like: boolean | null;
+    implementationChooseOne: boolean | null;
+    parentRelationType?: DataTypeParentChildRelation | null | undefined;
+    options?: string[] | undefined;
+}>;
+export declare function getDataTypeGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.DataType>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+} & {
+    entity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    foreignKeyRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    asType: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    like: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    isList: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    implementationChooseOne: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    foreignKeyAllowed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    staticEntities: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    interactiveEntities: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    actionEntities: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    parentRelationType: z.ZodOptional<z.ZodNullable<z.ZodEnum<[DataTypeParentChildRelation.AndDataTypeGroup, DataTypeParentChildRelation.OrDataTypeGroup]>>>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DataType;
+    id: string;
+    entity?: string | null | undefined;
+    foreignKeyRef?: string | null | undefined;
+    parentRelationType?: DataTypeParentChildRelation | null | undefined;
+    isList?: boolean | null | undefined;
+    asType?: boolean | null | undefined;
+    foreignKeyAllowed?: boolean | null | undefined;
+    interactiveEntities?: boolean | null | undefined;
+    staticEntities?: boolean | null | undefined;
+    actionEntities?: boolean | null | undefined;
+    options?: string[] | undefined;
+    like?: boolean | null | undefined;
+    implementationChooseOne?: boolean | null | undefined;
+}, {
+    type: EntityType.DataType;
+    id: string;
+    entity?: string | null | undefined;
+    foreignKeyRef?: string | null | undefined;
+    parentRelationType?: DataTypeParentChildRelation | null | undefined;
+    isList?: boolean | null | undefined;
+    asType?: boolean | null | undefined;
+    foreignKeyAllowed?: boolean | null | undefined;
+    interactiveEntities?: boolean | null | undefined;
+    staticEntities?: boolean | null | undefined;
+    actionEntities?: boolean | null | undefined;
+    options?: string[] | undefined;
+    like?: boolean | null | undefined;
+    implementationChooseOne?: boolean | null | undefined;
+}>;
+export declare function getDataTypeNestedEntitiesSchema(): z.ZodObject<{
+    entity: z.ZodNullable<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>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.PrimitiveEntity;
+    }, {
+        type: EntityType.PrimitiveEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ActionDescriptor;
+    }, {
+        type: EntityType.ActionDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>>;
+    foreignKeyRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.Property>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    }>>;
+    parent: z.ZodUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.Property>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    }>, z.ZodTypeAny, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.ValueDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ValueDescriptor;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ValueDescriptor;
+        entityId: string;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    entity: Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.ActionDescriptor;
+    } | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    } | null;
+    foreignKeyRef: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    } | null;
+    parent?: any;
+}, {
+    entity: Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.ActionDescriptor;
+    } | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    } | null;
+    foreignKeyRef: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    } | null;
+    parent?: any;
+}>;
+export declare function getDataTypeSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.DataType>;
+    isList: z.ZodNullable<z.ZodBoolean>;
+    asType: z.ZodNullable<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    like: z.ZodNullable<z.ZodBoolean>;
+    implementationChooseOne: z.ZodNullable<z.ZodBoolean>;
+    foreignKeyAllowed: z.ZodNullable<z.ZodBoolean>;
+    staticEntities: z.ZodNullable<z.ZodBoolean>;
+    interactiveEntities: z.ZodNullable<z.ZodBoolean>;
+    actionEntities: z.ZodNullable<z.ZodBoolean>;
+    parentRelationType: z.ZodOptional<z.ZodNullable<z.ZodEnum<[DataTypeParentChildRelation.AndDataTypeGroup, DataTypeParentChildRelation.OrDataTypeGroup]>>>;
+} & {
+    version: z.ZodString;
+} & {
+    entity: z.ZodNullable<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>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.PrimitiveEntity;
+    }, {
+        type: EntityType.PrimitiveEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ActionDescriptor;
+    }, {
+        type: EntityType.ActionDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>>;
+    foreignKeyRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.Property>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    }>>;
+    parent: z.ZodUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.Property>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    }>, z.ZodTypeAny, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+        entityId: z.ZodString;
+        entityType: z.ZodLiteral<EntityType.ValueDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ValueDescriptor;
+        entityId: string;
+    }, {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.ValueDescriptor;
+        entityId: string;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.DataType;
+    id: string;
+    version: string;
+    entity: Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.ActionDescriptor;
+    } | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    } | null;
+    foreignKeyRef: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    } | null;
+    isList: boolean | null;
+    asType: boolean | null;
+    foreignKeyAllowed: boolean | null;
+    interactiveEntities: boolean | null;
+    staticEntities: boolean | null;
+    actionEntities: boolean | null;
+    like: boolean | null;
+    implementationChooseOne: boolean | null;
+    parent?: any;
+    parentRelationType?: DataTypeParentChildRelation | null | undefined;
+    options?: string[] | undefined;
+}, {
+    type: EntityType.DataType;
+    id: string;
+    version: string;
+    entity: Record<string, any> | {
+        type: EntityType.BuiltInBaseEntity;
+    } | {
+        type: EntityType.ActionDescriptor;
+    } | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.DefinitionEntity;
+    } | null;
+    foreignKeyRef: {
+        type: EntityType.GenericReference;
+        id: string;
+        entityType: EntityType.Property;
+        entityId: string;
+    } | null;
+    isList: boolean | null;
+    asType: boolean | null;
+    foreignKeyAllowed: boolean | null;
+    interactiveEntities: boolean | null;
+    staticEntities: boolean | null;
+    actionEntities: boolean | null;
+    like: boolean | null;
+    implementationChooseOne: boolean | null;
+    parent?: any;
+    parentRelationType?: DataTypeParentChildRelation | null | undefined;
+    options?: string[] | undefined;
+}>;

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

@@ -0,0 +1,210 @@
+import { DefinitionEntityTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IDefinitionEntity, IDefinitionEntity_meta, IDefinitionEntityGenerationTarget, IDefinitionEntityReference, IDefinitionEntityShallowTransfer, IDefinitionEntityTransfer } from '../../../definitions';
+import { BaseCanvasDraggableState, UserManagedBaseState, ChildEntityBaseClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
+import { PropertyState } from '../property';
+import { FunctionDeclarationState } from '../function-declaration';
+import { ProjectState } from '../project/project';
+import { BuiltInBaseEntityState } from '../built-in-base-entity';
+import { ActionDescriptorState } from '../action-descriptor';
+import { EntityError, EntityGenerationError } from '../error';
+import { EntityState, UserManagedEntityState } from '../types';
+import { DataTypeState } from '../data-type';
+import { GenerationExplanationIds } from '../validate';
+import { VariableInputMapState } from '../input-map';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare enum DefinitionEntityDependencyField {
+    Extends = "extends",
+    Implements = "implements"
+}
+export declare class DefinitionEntityState extends UserManagedVersionedState implements UserManagedBaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, IDefinitionEntity, ChildEntityBaseClass {
+    initialData: IDefinitionEntity | IDefinitionEntityTransfer;
+    readonly id: EntityId;
+    name: string;
+    codeName: string | null;
+    description: string | null;
+    x: number;
+    y: number;
+    static: boolean;
+    abstract: boolean;
+    readonly type: EntityType.DefinitionEntity;
+    additionalProperties: boolean;
+    properties: PropertyState[];
+    allPropertiesImplement: PropertyState | null;
+    additionalPropertiesDataType: DataTypeState | null;
+    methods: FunctionDeclarationState[];
+    abstractMethods: ActionDescriptorState[];
+    extends: DefinitionEntityState | BuiltInBaseEntityState | null;
+    implements: (DefinitionEntityState | BuiltInBaseEntityState)[];
+    project: ProjectState;
+    errors: EntityError[];
+    parent: ProjectState | DataTypeState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    suggestedProperties: PropertyState[];
+    suggestedMethods: FunctionDeclarationState[];
+    constructor(initialData: IDefinitionEntity | IDefinitionEntityTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.DefinitionEntity;
+    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): IDefinitionEntityTransfer;
+    static fromGenerationTarget(data: IDefinitionEntityGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): DefinitionEntityState;
+    static validateGenerationTarget(data: IDefinitionEntityGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IDefinitionEntityGenerationTarget;
+    };
+    get interactive(): boolean;
+    get allMethods(): FunctionDeclarationState[];
+    get allProperties(): PropertyState[];
+    get allBaseMethodsFromOriginalParents(): FunctionDeclarationState[];
+    get allBasePropertiesFromOriginalParents(): PropertyState[];
+    get allBasePropertiesFromExtendedAndImplementedEntities(): PropertyState[];
+    get allBaseMethodsFromExtendedAndImplementedEntities(): (FunctionDeclarationState | ActionDescriptorState)[];
+    get extendedPropertiesFromOriginalParents(): PropertyState[];
+    get implementedPropertiesFromOriginalParents(): PropertyState[];
+    get extendedMethodsFromOriginalParents(): (FunctionDeclarationState | ActionDescriptorState)[];
+    get implementedMethodsFromOriginalParents(): (FunctionDeclarationState | ActionDescriptorState)[];
+    get extendedProperties(): PropertyState[];
+    get ownDeclaredProperties(): PropertyState[];
+    get extendedMethods(): FunctionDeclarationState[];
+    get ownDeclaredMethods(): FunctionDeclarationState[];
+    validateGeneratedUpdate(data: Partial<IDefinitionEntityGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IDefinitionEntityGenerationTarget>;
+    };
+    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(): DefinitionEntityState;
+    snapshot(): DefinitionEntityState;
+    /**
+     * 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 {DefinitionEntityState} snapshotInstance
+     * @returns {DefinitionEntityState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: DefinitionEntityState): DefinitionEntityState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<DefinitionEntityState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<DefinitionEntityState>>;
+    updateWithShallowTransfer(transfer: IDefinitionEntityShallowTransfer, changeSet?: ChangeSet | null): DefinitionEntityState;
+    updateWithGenerationTarget(transfer: Partial<IDefinitionEntityGenerationTarget>, changeSet?: ChangeSet | null): DefinitionEntityState;
+    hydrateAncestors(): IChangeSet<DefinitionEntityState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    setParent(parent: ProjectState | DataTypeState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    setExtension(entity: DefinitionEntityState | BuiltInBaseEntityState | null, changeSet?: ChangeSet | null): DefinitionEntityState;
+    addImplementation(entity: DefinitionEntityState | BuiltInBaseEntityState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    removeImplementation(entity: DefinitionEntityState | BuiltInBaseEntityState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    removeProperty(property: PropertyState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    addMethod(method: FunctionDeclarationState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    removeMethod(method: FunctionDeclarationState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    addProperty(property: PropertyState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    addSuggestedProperty(property: PropertyState): DefinitionEntityState;
+    addSuggestedMethod(method: FunctionDeclarationState): DefinitionEntityState;
+    removeSuggestedProperty(property: PropertyState): DefinitionEntityState;
+    removeSuggestedMethod(method: FunctionDeclarationState): DefinitionEntityState;
+    addAbstractMethod(method: ActionDescriptorState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    removeAbstractMethod(method: ActionDescriptorState, changeSet?: ChangeSet | null): DefinitionEntityState;
+    initChildren(changeSet?: ChangeSet | null): DefinitionEntityState;
+    removeUnrecognizedProperties(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    removeUnrecognizedMethods(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    syncImplementationMethods(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    syncImplementationProperties(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    addExtendedMethods(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    addExtendedProperties(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    addSuggestions(): DefinitionEntityState;
+    subscribe(): DefinitionEntityState;
+    unsubscribe(): DefinitionEntityState;
+    metaSync(changedData: Partial<IDefinitionEntity_meta | IDefinitionEntity | IDefinitionEntityTransfer | IDefinitionEntityShallowTransfer>, changeSet?: ChangeSet | null): DefinitionEntityState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IDefinitionEntityShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IDefinitionEntity_meta;
+    toJSON(seenEntities?: Set<EntityId>): IDefinitionEntityTransfer | IDefinitionEntityReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IDefinitionEntityTransfer | IDefinitionEntityReference;
+    toReference(options?: IEntityRecursionOptions): IDefinitionEntityReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IDefinitionEntityShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IDefinitionEntityGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): DefinitionEntityState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(changeSet?: ChangeSet | null, parent?: ProjectState | DataTypeState | null, newId?: string | null, subscribe?: boolean): DefinitionEntityState;
+    getFunctionDeclaration(id: EntityId): FunctionDeclarationState | undefined;
+    implement(newEntityName: string, changeSet?: ChangeSet | null, newId?: string): DefinitionEntityState;
+    getAllPropertiesImplements(): PropertyState[];
+    getAllInteractiveMethods(): (FunctionDeclarationState | ActionDescriptorState)[];
+    inferFromInputs(inputs: VariableInputMapState[], changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    getRawDefaultValue(): {
+        [propertyName: string]: any;
+    };
+    getActiveRawDefaultValue(): {
+        [propertyName: string]: any;
+    };
+    setAdditionalPropertiesDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): DefinitionEntityState;
+    removeAdditionalPropertiesDataType(changeSet?: ChangeSet | null): DefinitionEntityState;
+    setAllPropertiesImplement(property: PropertyState | null, changeSet?: ChangeSet | null): DefinitionEntityState;
+    removeAllPropertiesImplement(changeSet?: ChangeSet | null): DefinitionEntityState;
+}
+export type DefinitionEntityPayloadUnion = DefinitionEntityState | DefinitionEntityTypesUnion;

package/dist/tree/state/definition-entity/index.d.ts

@@ -0,0 +1,3 @@
+export * from './definition-entity';
+import * as definitionEntityValidation from './validation/logic-validation';
+export { definitionEntityValidation };

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

@@ -0,0 +1,18 @@
+import { ActionDescriptorState } from '../../action-descriptor';
+import { EntityError } from '../../error';
+import { DefinitionEntityState } from '../definition-entity';
+import { BuiltInBaseEntityState } from '../../built-in-base-entity';
+import { PropertyState } from '../../property';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare function validateAsync(self: DefinitionEntityState, options?: YieldOptions): Promise<EntityError[]>;
+export declare function validate(self: DefinitionEntityState): EntityError[];
+export declare function getBasePropertiesNotImplemented(self: DefinitionEntityState, implementedEntity: DefinitionEntityState | BuiltInBaseEntityState): PropertyState[];
+export declare function getBaseMethodsNotImplemented(self: DefinitionEntityState, implementedEntity: DefinitionEntityState | BuiltInBaseEntityState): ActionDescriptorState[];
+export declare function validateCanImplementEntity(self: DefinitionEntityState, entityToImplement: BuiltInBaseEntityState | DefinitionEntityState): EntityError[];
+export declare function validateCanExtendEntity(self: DefinitionEntityState, entityToExtend: BuiltInBaseEntityState | DefinitionEntityState, debug?: boolean): EntityError[];
+export declare function validateCanBecomeStatic(self: DefinitionEntityState): EntityError[];
+export declare function validateCanBecomeAbstract(self: DefinitionEntityState): EntityError[];
+export declare function validateCanBecomeNonStatic(self: DefinitionEntityState): EntityError[];
+export declare function validateCanBecomeNonAbstract(self: DefinitionEntityState): EntityError[];
+export declare function validateDefinitionEntityName(self: DefinitionEntityState, newName?: string): EntityError[];

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

@@ -0,0 +1,12 @@
+import { IDefinitionEntityGenerationTarget } from '../../../../definitions';
+import { EntityGenerationError } from '../../error';
+import { ProjectState } from '../../project';
+import { GenerationExplanationIds } from '../../validate';
+
+export declare function validateReferenceTypes(data: IDefinitionEntityGenerationTarget, project: ProjectState): {
+    errors: EntityGenerationError[];
+    explanations: {
+        id: GenerationExplanationIds;
+        message: string;
+    }[];
+};