@elyx-code/project-logic-tree 0.0.1

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

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

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

@@ -0,0 +1,180 @@
+import { EntityId, EntityType, EntityVersion, IProject, ICustomEntity, IFunctionDeclaration, IGlobalEvent, Element, IProjectTransfer, IGenericReference, ElementTransfer, Reference, IProjectReference, IFunctionCallTransfer, ICustomEntityTransfer, IFunctionDeclarationTransfer, IInstalledProjectTransfer, IVariableDeclarationTransfer, IProjectShallowTransfer, ElementShallowTransfer, ElementGenerationTarget, IProjectGenerationTarget, IConditionTransfer, IOperationTransfer, ProjectTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseState, UserManagedEntityStateFunctionality } from '../base';
+import { FunctionDeclarationState } from '../function-declaration';
+import { GlobalEventState } from '../global-event';
+import { CustomEntityState } from '../custom-entity';
+import { InstalledProjectState } from '../installed-project';
+import { VariableDeclarationState } from '../variable-declaration';
+import { ConditionState } from '../condition';
+import { FunctionCallState } from '../function-call';
+import { OperationState } from '../operation';
+import { DataTypeState, EntityState, EntryPointEntityState, PrimitiveEntityState, VariableState } from '..';
+import { LoopState } from '../loop';
+import { SearchState } from '../search';
+import { VariableInstanceState } from '../variable-instance';
+import { BuiltInBaseEntityState } from '../built-in-base-entity';
+import { EntityError, EntityGenerationError } from '../error';
+import { ActionDescriptorState } from '../action-descriptor';
+import { ValueDescriptorState } from '../value-descriptor';
+import { IModuleInjection } from '../types';
+
+export declare class ProjectState implements IProject, UserManagedEntityStateFunctionality, BaseState {
+    initialData: IProject | IProjectTransfer;
+    readonly id: EntityId;
+    version: EntityVersion;
+    type: EntityType.Project;
+    name: string | null;
+    description: string | null;
+    x: number;
+    y: number;
+    entities: CustomEntityState[];
+    projects: InstalledProjectState[];
+    functions: FunctionDeclarationState[];
+    events: GlobalEventState[];
+    variableDeclarations: VariableDeclarationState[];
+    variableInstances: VariableInstanceState[];
+    conditions: ConditionState[];
+    operations: OperationState[];
+    functionCalls: FunctionCallState[];
+    loops: LoopState[];
+    searches: SearchState[];
+    primitives: PrimitiveEntityState[];
+    builtInBaseEntities: BuiltInBaseEntityState[];
+    operationDeclarations: ActionDescriptorState[];
+    globalEventActionDescriptors: ActionDescriptorState[];
+    loopDeclarations: ActionDescriptorState[];
+    conditionDeclarations: ActionDescriptorState[];
+    valueDescriptors: ValueDescriptorState[];
+    dataTypes: DataTypeState[];
+    project: ProjectState;
+    instances: {
+        [id: string]: EntityState;
+    };
+    builtInInstances: {
+        [id: string]: EntityState;
+    };
+    errors: EntityError[];
+    references: IGenericReference[];
+    constructor(initialProjectData: IProject | IProjectTransfer);
+    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 validateGenerationTarget(data: IProjectGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IProjectGenerationTarget;
+    };
+    inject(...injectedModules: IModuleInjection[]): Promise<ProjectState>;
+    validateGeneratedUpdate(data: Partial<IProjectGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IProjectGenerationTarget>;
+    };
+    addSelfToProject(): ProjectState;
+    get instancesList(): EntityState[];
+    isOperationDeclaration(entity: ActionDescriptorState): boolean;
+    isGlobalEventActionDescriptor(entity: ActionDescriptorState): boolean;
+    isLoopDeclaration(entity: ActionDescriptorState): boolean;
+    isConditionDeclaration(entity: ActionDescriptorState): boolean;
+    initChildren(): ProjectState;
+    subscribeInstance(instance: EntityState): ProjectState;
+    subscribeBuiltInInstance(instance: EntityState): ProjectState;
+    subscribe(): ProjectState;
+    unsubscribe(): ProjectState;
+    unsubscribeInstance(entity: EntityState): ProjectState;
+    findSubscribedInstance(entity: Element | ElementTransfer): EntityState | null;
+    findSubscribedBuiltInInstance(entity: Element | ElementTransfer): EntityState | null;
+    get(entityId: EntityId): EntityState | null;
+    getManaged(entityId: EntityId): EntityState | null;
+    getBuiltIn(entityId: EntityId): EntityState | null;
+    findSubscribedInstanceFromReference(entity: Reference): EntityState | null;
+    findSubscribedBuiltInInstanceFromReference(entity: Reference): EntityState | null;
+    sync(data: Partial<IProject & {
+        x: number;
+        y: number;
+    }>): ProjectState;
+    load(): Promise<ProjectState>;
+    create(): Promise<ProjectState>;
+    update(_: Partial<ProjectTypesUnion>): Promise<ProjectState>;
+    delete(): Promise<ProjectState>;
+    remove({ ignoreUpstream: _ }?: {
+        ignoreUpstream: boolean;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities: _ }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: EntityState;
+    };
+    getAllBuiltInIds(): EntityId[];
+    getAllBuiltIn(): EntityState[];
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IProjectTransfer;
+    toReference(): IProjectReference;
+    toShallowJSON(): IProjectShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IProjectGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): ProjectState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IProjectTransfer | null;
+    };
+    validateChildren(): void;
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(): ProjectState;
+    getCustomEntity(id: EntityId): CustomEntityState | null;
+    addCustomEntityFromTransfer(entity: ICustomEntityTransfer): CustomEntityState;
+    addCustomEntity(entity: CustomEntityState): CustomEntityState;
+    addFunctionDeclarationFromTransfer(func: IFunctionDeclarationTransfer): FunctionDeclarationState;
+    addFunctionDeclaration(func: FunctionDeclarationState): FunctionDeclarationState;
+    addFunctionCallFromTransfer(func: IFunctionCallTransfer): FunctionCallState;
+    addFunctionCall(func: FunctionCallState): FunctionCallState;
+    addVariableDeclarationFromTransfer(variable: IVariableDeclarationTransfer): VariableDeclarationState;
+    addVariableDeclaration(variable: VariableDeclarationState): VariableDeclarationState;
+    addVariableInstanceFromTransfer(variable: IVariableDeclarationTransfer): VariableInstanceState;
+    addVariableInstance(variable: VariableInstanceState): VariableInstanceState;
+    addInstalledProjectFromTransfer(project: IInstalledProjectTransfer): ProjectState;
+    addInstalledProject(project: InstalledProjectState): ProjectState;
+    addGlobalEventFromTransfer(event: IGlobalEvent): ProjectState;
+    addGlobalEvent(event: GlobalEventState): ProjectState;
+    addConditionFromTransfer(condition: IConditionTransfer): ProjectState;
+    addCondition(condition: ConditionState): ProjectState;
+    addOperationFromTransfer(operation: IOperationTransfer): ProjectState;
+    addOperation(operation: OperationState): ProjectState;
+    addLoopFromTransfer(loop: LoopState): ProjectState;
+    addLoop(loop: LoopState): ProjectState;
+    addSearchFromTransfer(search: IConditionTransfer): ProjectState;
+    addSearch(search: SearchState): ProjectState;
+    removeCustomEntity(entity: ICustomEntity): CustomEntityState | null;
+    removeFunctionDeclaration(func: IFunctionDeclaration): FunctionDeclarationState | null;
+    removeExternalProject(project: IProject): InstalledProjectState | null;
+    removeGlobalEvent(event: IGlobalEvent): GlobalEventState | null;
+    removeTopLevelVariableDeclaration(variable: VariableDeclarationState): VariableDeclarationState | null;
+    getEntryPoints(): EntryPointEntityState[];
+    getFunctionDeclaration(id: EntityId): FunctionDeclarationState | null;
+    getConditions(): ConditionState[];
+    getOperations(): OperationState[];
+    getFunctionCalls(): FunctionCallState[];
+    getVariables(): VariableState[];
+    getVariableInstances(): VariableInstanceState[];
+    getVariableDeclarations(): VariableDeclarationState[];
+    attachOrphanReferences(): ProjectState;
+    getBuiltInPersistedEntity(): BuiltInBaseEntityState | null;
+}
+export type ProjectPayloadUnion = ProjectState | ProjectTypesUnion;

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

@@ -0,0 +1,389 @@
+import { EntityType } from '../../../../../../../../../../src/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, {
+    id: string;
+    type: EntityType.GenericReference;
+    entityType: EntityType.Project;
+    entityId: string;
+}, {
+    id: string;
+    type: EntityType.GenericReference;
+    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, {
+    id: string;
+    type: EntityType.Project;
+    name: string;
+    description: string | null;
+}, {
+    id: string;
+    type: EntityType.Project;
+    name: string;
+    description: string | null;
+}>;
+export declare function getProjectMetaSchema(): z.ZodObject<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Project>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, {
+    version: z.ZodNumber;
+}>, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.Project;
+    name: string;
+    description: string | null;
+    version: number;
+}, {
+    id: string;
+    type: EntityType.Project;
+    name: string;
+    description: string | null;
+    version: number;
+}>;
+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, {
+    id: string;
+    type: EntityType.Project;
+    name: string;
+    description: string | null;
+}, {
+    id: string;
+    type: EntityType.Project;
+    name: string;
+    description: string | null;
+}>;
+export declare function getProjectNestedEntitiesSchema(): z.ZodObject<{
+    entities: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.CustomEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.CustomEntity;
+    }, {
+        type: EntityType.CustomEntity;
+    }>, 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, {
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+    entities: (Record<string, any> | {
+        type: EntityType.CustomEntity;
+    })[];
+    projects: (Record<string, any> | {
+        type: EntityType.InstalledProject;
+    })[];
+    variableDeclarations: (Record<string, any> | {
+        type: EntityType.VariableDeclaration;
+    })[];
+    variableInstances: (Record<string, any> | {
+        type: EntityType.VariableInstance;
+    })[];
+    conditions: (Record<string, any> | {
+        type: EntityType.Condition;
+    })[];
+    operations: (Record<string, any> | {
+        type: EntityType.Operation;
+    })[];
+    functionCalls: (Record<string, any> | {
+        type: EntityType.FunctionCall;
+    })[];
+    loops: (Record<string, any> | {
+        type: EntityType.Loop;
+    })[];
+    searches: (Record<string, any> | {
+        type: EntityType.Search;
+    })[];
+}, {
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+    entities: (Record<string, any> | {
+        type: EntityType.CustomEntity;
+    })[];
+    projects: (Record<string, any> | {
+        type: EntityType.InstalledProject;
+    })[];
+    variableDeclarations: (Record<string, any> | {
+        type: EntityType.VariableDeclaration;
+    })[];
+    variableInstances: (Record<string, any> | {
+        type: EntityType.VariableInstance;
+    })[];
+    conditions: (Record<string, any> | {
+        type: EntityType.Condition;
+    })[];
+    operations: (Record<string, any> | {
+        type: EntityType.Operation;
+    })[];
+    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<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Project>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, {
+    version: z.ZodNumber;
+}>, {
+    entities: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.CustomEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.CustomEntity;
+    }, {
+        type: EntityType.CustomEntity;
+    }>, 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, {
+    id: string;
+    type: EntityType.Project;
+    name: string;
+    description: string | null;
+    version: number;
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+    entities: (Record<string, any> | {
+        type: EntityType.CustomEntity;
+    })[];
+    projects: (Record<string, any> | {
+        type: EntityType.InstalledProject;
+    })[];
+    variableDeclarations: (Record<string, any> | {
+        type: EntityType.VariableDeclaration;
+    })[];
+    variableInstances: (Record<string, any> | {
+        type: EntityType.VariableInstance;
+    })[];
+    conditions: (Record<string, any> | {
+        type: EntityType.Condition;
+    })[];
+    operations: (Record<string, any> | {
+        type: EntityType.Operation;
+    })[];
+    functionCalls: (Record<string, any> | {
+        type: EntityType.FunctionCall;
+    })[];
+    loops: (Record<string, any> | {
+        type: EntityType.Loop;
+    })[];
+    searches: (Record<string, any> | {
+        type: EntityType.Search;
+    })[];
+}, {
+    id: string;
+    type: EntityType.Project;
+    name: string;
+    description: string | null;
+    version: number;
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+    entities: (Record<string, any> | {
+        type: EntityType.CustomEntity;
+    })[];
+    projects: (Record<string, any> | {
+        type: EntityType.InstalledProject;
+    })[];
+    variableDeclarations: (Record<string, any> | {
+        type: EntityType.VariableDeclaration;
+    })[];
+    variableInstances: (Record<string, any> | {
+        type: EntityType.VariableInstance;
+    })[];
+    conditions: (Record<string, any> | {
+        type: EntityType.Condition;
+    })[];
+    operations: (Record<string, any> | {
+        type: EntityType.Operation;
+    })[];
+    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 @@
+export * from './property';

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

@@ -0,0 +1,100 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IProperty, IPropertyGenerationTarget, IPropertyReference, IPropertyShallowTransfer, IPropertyTransfer, PropertyTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseState, ChildEntityState, EntityWithValueClass, UserManagedEntityStateFunctionality } from '../base';
+import { DataTypeState } from '../data-type';
+import { ProjectState } from '../project/project';
+import { PrimitiveEntityState } from '../primitive-entity';
+import { CustomEntityState } from '../custom-entity';
+import { BuiltInBaseEntityState } from '../built-in-base-entity';
+import { EntityError, EntityGenerationError } from '../error';
+import { PrimitiveValueState } from '../primitive-value';
+import { EntityState } from '../types';
+
+export declare class PropertyState implements IProperty, UserManagedEntityStateFunctionality, BaseState, ChildEntityState, EntityWithValueClass {
+    initialData: IProperty | IPropertyTransfer;
+    readonly id: EntityId;
+    version: EntityVersion;
+    name: string;
+    description: string | null;
+    private: boolean;
+    abstract: boolean;
+    index: number;
+    static: boolean;
+    required: boolean;
+    readonly type: EntityType.Property;
+    dataType: DataTypeState | null;
+    implements: PropertyState | null;
+    project: ProjectState;
+    errors: EntityError[];
+    parent: CustomEntityState | PrimitiveEntityState | BuiltInBaseEntityState;
+    initialized: boolean;
+    suggestion: boolean;
+    constructor(initialPropertyData: IProperty | IPropertyTransfer, 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: IPropertyGenerationTarget, parentProjectState: ProjectState): PropertyState;
+    static validateGenerationTarget(data: IPropertyGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IPropertyGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IPropertyGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IPropertyGenerationTarget>;
+    };
+    addSelfToProject(): PropertyState;
+    setParent(parent: CustomEntityState | PrimitiveEntityState | BuiltInBaseEntityState): PropertyState;
+    initChildren(): PropertyState;
+    subscribe(): PropertyState;
+    unsubscribe(): PropertyState;
+    sync(data: Partial<IProperty>): PropertyState;
+    load(): Promise<PropertyState>;
+    create(): Promise<PropertyState>;
+    update(_: Partial<PropertyTypesUnion>): Promise<PropertyState>;
+    delete(): Promise<PropertyState>;
+    remove({ ignoreUpstream, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: PropertyState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IPropertyTransfer;
+    toReference(): IPropertyReference;
+    toShallowJSON(): IPropertyShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IPropertyGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): PropertyState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IPropertyTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    getDefaultValue(): PrimitiveValueState | null;
+    clone(parent?: CustomEntityState | null, newId?: string | null, subscribe?: boolean): PropertyState;
+    setDataType(dataType: DataTypeState): PropertyState;
+    removeDataType(): PropertyState;
+    getDataType(): DataTypeState | null;
+}
+export type PropertyPayloadUnion = PropertyState | PropertyTypesUnion;

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

@@ -0,0 +1,5 @@
+import { EntityError } from '../../error';
+import { PropertyState } from '../property';
+
+export declare function validate(self: PropertyState): EntityError[];
+export declare function validateImplementation(self: PropertyState): EntityError[];

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

@@ -0,0 +1,5 @@
+import { IPropertyGenerationTarget } from '../../../../../../../../../../src/definitions';
+import { EntityGenerationError } from '../../error';
+import { ProjectState } from '../../project';
+
+export declare function validateReferenceTypes(data: IPropertyGenerationTarget, project: ProjectState): EntityGenerationError[];