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

package/dist/tree/state/project/validation/validation-schema.d.ts

@@ -0,0 +1,389 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getProjectTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.Project>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Project;
+}, {
+    type: EntityType.Project;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getProjectReferenceSchema(): 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;
+}>;
+export declare function getProjectBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Project>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Project;
+    id: string;
+    name: string;
+    description: string | null;
+}, {
+    type: EntityType.Project;
+    id: string;
+    name: string;
+    description: string | null;
+}>;
+export declare function getProjectMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Project>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+} & {
+    version: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Project;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+}, {
+    type: EntityType.Project;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+}>;
+export declare function getProjectGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Project>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Project;
+    id: string;
+    name: string;
+    description: string | null;
+}, {
+    type: EntityType.Project;
+    id: string;
+    name: string;
+    description: string | null;
+}>;
+export declare function getProjectNestedEntitiesSchema(): z.ZodObject<{
+    entities: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.DefinitionEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DefinitionEntity;
+    }, {
+        type: EntityType.DefinitionEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    functions: 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">;
+    events: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.GlobalEvent>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GlobalEvent;
+    }, {
+        type: EntityType.GlobalEvent;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    projects: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InstalledProject>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InstalledProject;
+    }, {
+        type: EntityType.InstalledProject;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    variableDeclarations: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.VariableDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.VariableDeclaration;
+    }, {
+        type: EntityType.VariableDeclaration;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    variableInstances: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.VariableInstance>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.VariableInstance;
+    }, {
+        type: EntityType.VariableInstance;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    conditions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Condition>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Condition;
+    }, {
+        type: EntityType.Condition;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    operations: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Operation>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Operation;
+    }, {
+        type: EntityType.Operation;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    functionCalls: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.FunctionCall>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.FunctionCall;
+    }, {
+        type: EntityType.FunctionCall;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    loops: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Loop>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Loop;
+    }, {
+        type: EntityType.Loop;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    searches: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Search>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Search;
+    }, {
+        type: EntityType.Search;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    projects: (Record<string, any> | {
+        type: EntityType.InstalledProject;
+    })[];
+    entities: (Record<string, any> | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+    variableDeclarations: (Record<string, any> | {
+        type: EntityType.VariableDeclaration;
+    })[];
+    variableInstances: (Record<string, any> | {
+        type: EntityType.VariableInstance;
+    })[];
+    operations: (Record<string, any> | {
+        type: EntityType.Operation;
+    })[];
+    conditions: (Record<string, any> | {
+        type: EntityType.Condition;
+    })[];
+    functionCalls: (Record<string, any> | {
+        type: EntityType.FunctionCall;
+    })[];
+    loops: (Record<string, any> | {
+        type: EntityType.Loop;
+    })[];
+    searches: (Record<string, any> | {
+        type: EntityType.Search;
+    })[];
+}, {
+    projects: (Record<string, any> | {
+        type: EntityType.InstalledProject;
+    })[];
+    entities: (Record<string, any> | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+    variableDeclarations: (Record<string, any> | {
+        type: EntityType.VariableDeclaration;
+    })[];
+    variableInstances: (Record<string, any> | {
+        type: EntityType.VariableInstance;
+    })[];
+    operations: (Record<string, any> | {
+        type: EntityType.Operation;
+    })[];
+    conditions: (Record<string, any> | {
+        type: EntityType.Condition;
+    })[];
+    functionCalls: (Record<string, any> | {
+        type: EntityType.FunctionCall;
+    })[];
+    loops: (Record<string, any> | {
+        type: EntityType.Loop;
+    })[];
+    searches: (Record<string, any> | {
+        type: EntityType.Search;
+    })[];
+}>;
+export declare function getProjectSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Project>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+} & {
+    version: z.ZodString;
+} & {
+    entities: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.DefinitionEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.DefinitionEntity;
+    }, {
+        type: EntityType.DefinitionEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    functions: 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">;
+    events: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.GlobalEvent>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GlobalEvent;
+    }, {
+        type: EntityType.GlobalEvent;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    projects: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InstalledProject>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InstalledProject;
+    }, {
+        type: EntityType.InstalledProject;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    variableDeclarations: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.VariableDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.VariableDeclaration;
+    }, {
+        type: EntityType.VariableDeclaration;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    variableInstances: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.VariableInstance>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.VariableInstance;
+    }, {
+        type: EntityType.VariableInstance;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    conditions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Condition>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Condition;
+    }, {
+        type: EntityType.Condition;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    operations: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Operation>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Operation;
+    }, {
+        type: EntityType.Operation;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    functionCalls: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.FunctionCall>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.FunctionCall;
+    }, {
+        type: EntityType.FunctionCall;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    loops: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Loop>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Loop;
+    }, {
+        type: EntityType.Loop;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    searches: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Search>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Search;
+    }, {
+        type: EntityType.Search;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Project;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    projects: (Record<string, any> | {
+        type: EntityType.InstalledProject;
+    })[];
+    entities: (Record<string, any> | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+    variableDeclarations: (Record<string, any> | {
+        type: EntityType.VariableDeclaration;
+    })[];
+    variableInstances: (Record<string, any> | {
+        type: EntityType.VariableInstance;
+    })[];
+    operations: (Record<string, any> | {
+        type: EntityType.Operation;
+    })[];
+    conditions: (Record<string, any> | {
+        type: EntityType.Condition;
+    })[];
+    functionCalls: (Record<string, any> | {
+        type: EntityType.FunctionCall;
+    })[];
+    loops: (Record<string, any> | {
+        type: EntityType.Loop;
+    })[];
+    searches: (Record<string, any> | {
+        type: EntityType.Search;
+    })[];
+}, {
+    type: EntityType.Project;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    projects: (Record<string, any> | {
+        type: EntityType.InstalledProject;
+    })[];
+    entities: (Record<string, any> | {
+        type: EntityType.DefinitionEntity;
+    })[];
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+    variableDeclarations: (Record<string, any> | {
+        type: EntityType.VariableDeclaration;
+    })[];
+    variableInstances: (Record<string, any> | {
+        type: EntityType.VariableInstance;
+    })[];
+    operations: (Record<string, any> | {
+        type: EntityType.Operation;
+    })[];
+    conditions: (Record<string, any> | {
+        type: EntityType.Condition;
+    })[];
+    functionCalls: (Record<string, any> | {
+        type: EntityType.FunctionCall;
+    })[];
+    loops: (Record<string, any> | {
+        type: EntityType.Loop;
+    })[];
+    searches: (Record<string, any> | {
+        type: EntityType.Search;
+    })[];
+}>;

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

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

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

@@ -0,0 +1,179 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IProperty, IProperty_meta, IPropertyGenerationTarget, IPropertyReference, IPropertyShallowTransfer, IPropertyTransfer, PropertyParentChildRelation, PropertyTypesUnion } from '../../../definitions';
+import { UserManagedBaseState, ChildEntityBaseClass, EntityWithDefaultValueClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, IEntityJSONCloneOptions, IEntityRecursionOptions, ValueValidationCallback } from '../base';
+import { DataTypeState } from '../data-type';
+import { ProjectState } from '../project/project';
+import { PrimitiveEntityState } from '../primitive-entity';
+import { DefinitionEntityState } from '../definition-entity';
+import { BuiltInBaseEntityState } from '../built-in-base-entity';
+import { EntityError, EntityGenerationError } from '../error';
+import { LiteralValueState } from '../literal-value';
+import { EntityState, PassThroughCallableEntityState, TerminationEntityState, UserManagedEntityState } from '../types';
+import { GenerationExplanationIds } from '../validate';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+import { InputMapState } from '../input-map';
+
+export declare enum PropertyDependencyField {
+    PropertyImplements = "property-implements-field",
+    PropertyExtends = "property-extends-field",
+    PropertyDataTypeEntity = "property-data-type-entity-field",
+    PropertyDataType = "property-data-type-field"
+}
+export declare class PropertyState extends UserManagedVersionedState implements IProperty, UserManagedEntityStateTemplate, UserManagedBaseState, ChildEntityBaseClass, EntityWithDefaultValueClass {
+    initialData: IProperty | IPropertyTransfer;
+    readonly id: EntityId;
+    name: string;
+    codeName: string | null;
+    description: string | null;
+    private: boolean;
+    abstract: boolean;
+    index: number;
+    static: boolean;
+    unique: boolean;
+    required: boolean;
+    constant: boolean;
+    interactive: boolean;
+    readonly type: EntityType.Property;
+    hidden: boolean;
+    parentRelationType: PropertyParentChildRelation | null;
+    defaultValue: LiteralValueState | null;
+    dataType: DataTypeState | null;
+    implements: PropertyState[];
+    extends: PropertyState | null;
+    project: ProjectState;
+    errors: EntityError[];
+    parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    suggestion: boolean;
+    readonly _codeNativeValueValidation: ValueValidationCallback | null;
+    constructor(initialData: IProperty | IPropertyTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.Property;
+    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): IPropertyTransfer;
+    static fromGenerationTarget(data: IPropertyGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): PropertyState;
+    static validateGenerationTarget(data: IPropertyGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IPropertyGenerationTarget;
+    };
+    get isExtendedProperty(): boolean;
+    get codeNativeValueValidation(): ValueValidationCallback | null;
+    validateGeneratedUpdate(data: Partial<IPropertyGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IPropertyGenerationTarget>;
+    };
+    onProjectInitialized(_project: ProjectState, changeSet?: ChangeSet | null): PropertyState;
+    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(): PropertyState;
+    snapshot(): PropertyState;
+    /**
+     * 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 {PropertyState} snapshotInstance
+     * @returns {PropertyState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: PropertyState): PropertyState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<PropertyState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<PropertyState>>;
+    updateWithShallowTransfer(transfer: IPropertyShallowTransfer, changeSet?: ChangeSet | null): PropertyState;
+    updateWithGenerationTarget(transfer: Partial<IPropertyGenerationTarget>, changeSet?: ChangeSet | null): PropertyState;
+    hydrateAncestors(): IChangeSet<PropertyState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<PropertyState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<PropertyState>;
+    setParent(parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState, changeSet?: ChangeSet | null): PropertyState;
+    addImplementation(entity: PropertyState, changeSet?: ChangeSet | null): PropertyState;
+    removeImplementation(entity: PropertyState, changeSet?: ChangeSet | null): PropertyState;
+    setExtends(extendsEntity: PropertyState | null, changeSet?: ChangeSet | null): PropertyState;
+    initChildren(changeSet?: ChangeSet | null): PropertyState;
+    subscribe(): PropertyState;
+    unsubscribe(): PropertyState;
+    metaSync(changedData: Partial<IProperty_meta | IProperty | IPropertyTransfer | IPropertyShallowTransfer>, changeSet?: ChangeSet | null): PropertyState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IPropertyShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<PropertyState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IProperty_meta;
+    toJSON(seenEntities?: Set<EntityId>): IPropertyTransfer | IPropertyReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IPropertyTransfer | IPropertyReference;
+    toReference(options?: IEntityRecursionOptions): IPropertyReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IPropertyShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IPropertyGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): PropertyState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    implement(parent: DefinitionEntityState, changeSet?: ChangeSet | null, newId?: string | null): PropertyState;
+    clone(changeSet?: ChangeSet | null, parent?: DefinitionEntityState | null, newId?: string | null, subscribe?: boolean): PropertyState;
+    setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): PropertyState;
+    removeDataType(changeSet?: ChangeSet | null): PropertyState;
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+    getDefaultValue(): LiteralValueState | null;
+    setDefaultValue(value: LiteralValueState | null, changeSet?: ChangeSet | null): PropertyState;
+    syncWithImplementation(changeSet?: ChangeSet | null): IChangeSet<PropertyState>;
+    syncWithExtension(changeSet?: ChangeSet | null): IChangeSet<PropertyState>;
+    implementAsInputMap(changeSet: (ChangeSet | null) | undefined, newParent: PassThroughCallableEntityState | TerminationEntityState, newId?: string): InputMapState;
+}
+export type PropertyPayloadUnion = PropertyState | PropertyTypesUnion;

package/dist/tree/state/property/utils.d.ts

@@ -0,0 +1,11 @@
+import { ChangeSet, IChangeSet } from '../change-set';
+import { PropertyState } from './property';
+import { PrimitiveTypes } from '../../../definitions';
+
+export declare function checkIsEnumOfOneOrLiteralString(self: PropertyState): {
+    result: boolean;
+    value: string | null;
+    name: PrimitiveTypes.String | PrimitiveTypes.Number | PrimitiveTypes.UUID | PrimitiveTypes.Boolean | PrimitiveTypes.Date | PrimitiveTypes.Bytes | null;
+};
+export declare function checkNeedsSideEffectsAfterPropertyInitialized(self: PropertyState): boolean;
+export declare function afterPropertyInitializedSideEffects(self: PropertyState, changeSet: ChangeSet | null): IChangeSet<PropertyState>;

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

@@ -0,0 +1,8 @@
+import { EntityError } from '../../error';
+import { PropertyState } from '../property';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare function validateAsync(self: PropertyState, options?: YieldOptions): Promise<EntityError[]>;
+export declare function validate(self: PropertyState): EntityError[];
+export declare function validateImplementation(self: PropertyState, implementedProperty: PropertyState): EntityError[];
+export declare function validatePropertyEntityName(self: PropertyState, newName?: string): EntityError[];

package/dist/tree/state/property/validation/references.d.ts

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