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

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

@@ -0,0 +1,198 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, ISearch, ISearchGenerationTarget, ISearchReference, ISearchShallowTransfer, ISearchTransfer, ISearch_meta, SearchTypesUnion } from '../../../definitions';
+import { BaseCanvasDraggableState, UserManagedBaseState, CallableEntityClass, ChildEntityBaseClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate, ValueWritingEntityClass } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState, ValueReadingEntityState } from '../types';
+import { ActionInputMapState } from '../input-map';
+import { ActionOutputMapState } from '../output-map';
+import { ProjectState } from '../project/project';
+import { EntityError, EntityGenerationError } from '../../state/error';
+import { GenerationExplanationIds } from '../validate';
+import { ValueDescriptorState } from '../value-descriptor';
+import { UserManagedVersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
+import { DefinitionEntityState } from '../definition-entity';
+import { SearchStatementState } from './query/search-statement-state';
+import { DataTypeState } from '../data-type';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare enum SearchDependencyField {
+    Parent = "search-parent-field",
+    DataTypeEntity = "search-data-type-entity-field",
+    DataType = "search-data-type-field"
+}
+export declare class SearchState extends UserManagedVersionedState implements ISearch, UserManagedBaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, ValueWritingEntityClass, CallableEntityClass, ChildEntityBaseClass, PassThroughCallableEntityClass {
+    initialData: ISearch | ISearchTransfer;
+    readonly id: EntityId;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    query: string;
+    readonly type: EntityType.Search;
+    catchesError: boolean;
+    writesValues: ValueReadingEntityState[];
+    dataType: DataTypeState | null;
+    successCalls: CallableEntityState[];
+    errorCalls: CallableEntityState[];
+    inputsDeclarations: ValueDescriptorState[];
+    inputs: ActionInputMapState[];
+    outputs: ActionOutputMapState[];
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    error: ActionOutputMapState | null;
+    parent: EntityWithLogicScopeState | ProjectState;
+    errors: EntityError[];
+    project: ProjectState;
+    state: SearchStatementState | null;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    constructor(initialData: ISearch | ISearchTransfer, parentProjectState: ProjectState);
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.Search;
+    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): ISearchTransfer;
+    static fromGenerationTarget(data: ISearchGenerationTarget, parentProjectState: ProjectState, _changeSet?: ChangeSet | null): SearchState;
+    static validateGenerationTarget(data: ISearchGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: ISearchGenerationTarget;
+    };
+    get resultsAsList(): boolean;
+    queryToState(): SearchStatementState;
+    stateToQuery(): string;
+    rehydrateQuery(): string;
+    onProjectInitialized(_project: ProjectState, changeSet?: ChangeSet | null): SearchState;
+    onPersistedEntityUpdated(_updatedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
+    onPersistedEntityAdded(_newEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
+    onPersistedEntityRemoved(_removedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
+    onRelationalDatabaseEntityUpdated(_updatedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
+    onRelationalDatabaseEntityAdded(_newEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
+    onRelationalDatabaseEntityRemoved(_removedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
+    validateGeneratedUpdate(data: Partial<ISearchGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<ISearchGenerationTarget>;
+    };
+    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(): SearchState;
+    snapshot(): SearchState;
+    /**
+     * 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 {SearchState} snapshotInstance
+     * @returns {SearchState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: SearchState): SearchState;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<SearchState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<SearchState>>;
+    updateWithShallowTransfer(transfer: ISearchShallowTransfer, changeSet?: ChangeSet | null): SearchState;
+    updateWithGenerationTarget(transfer: Partial<ISearchGenerationTarget>, changeSet?: ChangeSet | null): SearchState;
+    hydrateAncestors(): IChangeSet<SearchState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
+    get calledBy(): CallerEntityState[];
+    removeInput(input: ActionInputMapState, changeSet?: ChangeSet | null): SearchState;
+    addInput(input: ActionInputMapState, changeSet?: ChangeSet | null): SearchState;
+    addInputDeclaration(inputDeclaration: ValueDescriptorState, changeSet?: ChangeSet | null): SearchState;
+    removeInputDeclaration(inputDeclaration: ValueDescriptorState, changeSet?: ChangeSet | null): SearchState;
+    addOutput(output: ActionOutputMapState, changeSet?: ChangeSet | null): SearchState;
+    removeOutput(output: ActionOutputMapState, changeSet?: ChangeSet | null): SearchState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
+    addErrorCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
+    addSuccessCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
+    removeCall(call: CallableEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null, recalculateScope?: boolean): SearchState;
+    setError(error: ActionOutputMapState | null, changeSet?: ChangeSet | null): SearchState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): SearchState;
+    initChildren(changeSet?: ChangeSet | null): SearchState;
+    subscribe(): SearchState;
+    unsubscribe(): SearchState;
+    metaSync(changedData: Partial<ISearch_meta | ISearch | ISearchTransfer | ISearchShallowTransfer>, changeSet?: ChangeSet | null): SearchState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<ISearchShallowTransfer | null>;
+    removeFromParent(changeSet?: ChangeSet | null): IChangeSet;
+    remove({ ignoreUpstream }?: {
+        ignoreUpstream: boolean;
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<EntityState>;
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): ISearch_meta;
+    toJSON(seenEntities?: Set<EntityId>): ISearchTransfer | ISearchReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): ISearchTransfer | ISearchReference;
+    toReference(options?: IEntityRecursionOptions): ISearchReference;
+    toShallowJSON(options?: IEntityRecursionOptions): ISearchShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): ISearchGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): SearchState;
+    validate(): {
+        success: boolean;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(changeSet?: ChangeSet | null, parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): SearchState;
+    syncInputMaps(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
+    getUnusedInputs(): ActionInputMapState[];
+    getUnusedOutputs(): ActionOutputMapState[];
+    getUsedInputs(): ActionInputMapState[];
+    getUsedOutputs(): ActionOutputMapState[];
+    addValueReader(entity: ValueReadingEntityState, changeSet?: ChangeSet | null): SearchState;
+    removeValueReader(valueReader: ValueReadingEntityState, changeSet?: ChangeSet | null): SearchState;
+    setDataType(dataType: DataTypeState | null, changeSet?: ChangeSet | null): SearchState;
+    removeDataType(changeSet?: ChangeSet | null): SearchState;
+    getDataType(changeSet?: ChangeSet | null): DataTypeState | null;
+}
+export type SearchPayloadUnion = SearchState | SearchTypesUnion;

package/dist/tree/state/search/search.part3.test-process.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import { PrimitiveTypes } from '../../../definitions';
+import { ChangeSet, DefinitionEntityState, PrimitiveEntityState, ProjectState, SearchState } from '..';
+import { SearchStatementState } from './query/search-statement-state';
+import { SearchLiteralValueType } from './query/defs';
+
+export declare function resolvePrimitiveEntityForSQLDataType(dataType: string | null, project: ProjectState): PrimitiveEntityState;
+export declare function fromLiteralValueTypeToPrimitiveType(valueType: SearchLiteralValueType): PrimitiveTypes;
+export declare function resolvePrimitiveEntityForSearchLiteralValueType(valueType: SearchLiteralValueType, project: ProjectState): PrimitiveEntityState;
+export declare function checkIsDefEntityInlineDeclaredForSearchOutputType(entity: DefinitionEntityState | null): boolean;
+export declare function syncSearchEntityOutput(entity: SearchState, statement: SearchStatementState, changeSet: ChangeSet | null): void;

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

@@ -0,0 +1,6 @@
+import { EntityError } from '../../error';
+import { SearchState } from '../search';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare function validateAsync(self: SearchState, options?: YieldOptions): Promise<EntityError[]>;
+export declare function validate(self: SearchState): EntityError[];

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

@@ -0,0 +1,323 @@
+import { EntityType } from '../../../../definitions';
+import { z } from 'zod';
+
+export declare function getSearchTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.Search>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Search;
+}, {
+    type: EntityType.Search;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getSearchReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.Search>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.Search;
+    entityId: string;
+}, {
+    type: EntityType.GenericReference;
+    id: string;
+    entityType: EntityType.Search;
+    entityId: string;
+}>;
+export declare function getSearchBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Search>;
+    name: z.ZodString;
+    query: z.ZodAny;
+    description: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Search;
+    id: string;
+    name: string;
+    description: string | null;
+    query?: any;
+}, {
+    type: EntityType.Search;
+    id: string;
+    name: string;
+    description: string | null;
+    query?: any;
+}>;
+export declare function getSearchMetaSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Search>;
+    name: z.ZodString;
+    query: z.ZodAny;
+    description: z.ZodNullable<z.ZodString>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Search;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    query?: any;
+}, {
+    type: EntityType.Search;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    query?: any;
+}>;
+export declare function getSearchGenerationTargetSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Search>;
+    name: z.ZodString;
+    query: z.ZodAny;
+    description: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.Search;
+    id: string;
+    name: string;
+    description: string | null;
+    query?: any;
+}, {
+    type: EntityType.Search;
+    id: string;
+    name: string;
+    description: string | null;
+    query?: any;
+}>;
+export declare function getSearchNestedEntitiesSchema(): z.ZodObject<{
+    successCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    errorCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
+    inputsDeclarations: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ArgumentDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ArgumentDeclaration;
+    }, {
+        type: EntityType.ArgumentDeclaration;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    inputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InputMap;
+    }, {
+        type: EntityType.InputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    outputsDeclarations: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ValueDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ValueDescriptor;
+    }, {
+        type: EntityType.ValueDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    outputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    parent: z.ZodUnion<[z.ZodTypeAny, 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;
+    }>]>;
+    error: z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+}, "strip", z.ZodTypeAny, {
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    error: Record<string, any> | {
+        type: EntityType.OutputMap;
+    } | null;
+    inputsDeclarations: (Record<string, any> | {
+        type: EntityType.ArgumentDeclaration;
+    })[];
+    outputsDeclarations: (Record<string, any> | {
+        type: EntityType.ValueDescriptor;
+    })[];
+    parent?: any;
+}, {
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    error: Record<string, any> | {
+        type: EntityType.OutputMap;
+    } | null;
+    inputsDeclarations: (Record<string, any> | {
+        type: EntityType.ArgumentDeclaration;
+    })[];
+    outputsDeclarations: (Record<string, any> | {
+        type: EntityType.ValueDescriptor;
+    })[];
+    parent?: any;
+}>;
+export declare function getSearchSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.Search>;
+    name: z.ZodString;
+    query: z.ZodAny;
+    description: z.ZodNullable<z.ZodString>;
+} & {
+    version: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+} & {
+    successCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    errorCalls: z.ZodArray<z.ZodTypeAny, "many">;
+    calledBySuccess: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByError: z.ZodArray<z.ZodTypeAny, "many">;
+    calledByEntry: z.ZodArray<z.ZodTypeAny, "many">;
+    inputsDeclarations: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ArgumentDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ArgumentDeclaration;
+    }, {
+        type: EntityType.ArgumentDeclaration;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    inputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.InputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.InputMap;
+    }, {
+        type: EntityType.InputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    outputsDeclarations: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ValueDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ValueDescriptor;
+    }, {
+        type: EntityType.ValueDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    outputs: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    parent: z.ZodUnion<[z.ZodTypeAny, 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;
+    }>]>;
+    error: z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.OutputMap>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.OutputMap;
+    }, {
+        type: EntityType.OutputMap;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+}, "strip", z.ZodTypeAny, {
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    error: Record<string, any> | {
+        type: EntityType.OutputMap;
+    } | null;
+    type: EntityType.Search;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    inputsDeclarations: (Record<string, any> | {
+        type: EntityType.ArgumentDeclaration;
+    })[];
+    outputsDeclarations: (Record<string, any> | {
+        type: EntityType.ValueDescriptor;
+    })[];
+    parent?: any;
+    query?: any;
+}, {
+    inputs: (Record<string, any> | {
+        type: EntityType.InputMap;
+    })[];
+    outputs: (Record<string, any> | {
+        type: EntityType.OutputMap;
+    })[];
+    successCalls: any[];
+    errorCalls: any[];
+    calledBySuccess: any[];
+    calledByError: any[];
+    calledByEntry: any[];
+    error: Record<string, any> | {
+        type: EntityType.OutputMap;
+    } | null;
+    type: EntityType.Search;
+    id: string;
+    version: string;
+    name: string;
+    description: string | null;
+    x: number;
+    y: number;
+    inputsDeclarations: (Record<string, any> | {
+        type: EntityType.ArgumentDeclaration;
+    })[];
+    outputsDeclarations: (Record<string, any> | {
+        type: EntityType.ValueDescriptor;
+    })[];
+    parent?: any;
+    query?: any;
+}>;

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

@@ -0,0 +1,121 @@
+import { EntityId, IProjectShallowTransfer, IProjectTransfer, UserManagedElementShallowTransfer } from '../../definitions';
+import { IProjectInstanceParentContext, ProjectState } from './project/project';
+import { UserManagedEntityState } from './types';
+import { ChangeSet } from './change-set/change-set';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare const CACHED_PROJECTS_BY_ID: {
+    [id: string]: ProjectState;
+};
+export interface IProjectFetchResult {
+    project: IProjectShallowTransfer;
+    record: Record<EntityId, UserManagedElementShallowTransfer>;
+}
+export type ProjectFetchResult = null | IProjectFetchResult;
+export interface IGetProjectOptions {
+    empty?: boolean;
+    authToken?: string | null;
+    enrich?: boolean;
+    mock?: boolean;
+    baseUrl?: string;
+    ignoreCache?: boolean;
+    onFetch?: (projectId: EntityId) => Promise<ProjectFetchResult | ProjectState>;
+    manuallyInit?: boolean;
+}
+export declare const GET_PROJECT_OPTIONS_DEFAULTS: IGetProjectOptions;
+export declare function initProjectFromFetchResult(result: IProjectFetchResult, options?: {
+    enrich?: boolean;
+    shallowErrors?: boolean;
+}, parentContext?: IProjectInstanceParentContext): ProjectState;
+export declare function initProjectFromFetchResultAsync(result: IProjectFetchResult, options?: {
+    enrich?: boolean;
+    shallowErrors?: boolean;
+    yieldEvery?: number;
+}, parentContext?: IProjectInstanceParentContext): Promise<ProjectState>;
+export declare function initBaseProjectEntity(data: IProjectTransfer, options?: {
+    shallowErrors?: boolean;
+    allBuiltInIds?: Set<EntityId>;
+}, parentContext?: IProjectInstanceParentContext): ProjectState;
+export declare function initBaseProjectEntityAsync(data: IProjectTransfer, options?: YieldOptions & {
+    shallowErrors?: boolean;
+    allBuiltInIds?: Set<EntityId>;
+}, parentContext?: IProjectInstanceParentContext): Promise<ProjectState>;
+export declare function getEntitiesCreatedSinceInitialization(projectState: ProjectState, preInitDate: string): UserManagedEntityState[];
+export declare function cloneProject(project: ProjectState, { enrich, shallowErrors, ...other }?: {
+    enrich?: boolean;
+    shallowErrors?: boolean;
+    resetVersionOptions?: {
+        commonTimestamp?: string;
+        author?: string;
+    };
+    onVisit?: (entity: UserManagedElementShallowTransfer) => void;
+}, parentContext?: IProjectInstanceParentContext): {
+    project: ProjectState;
+    maps: Map<EntityId, EntityId>;
+};
+export declare function cloneToShallowRecordAsync(project: ProjectState, { shallowErrors, ...other }?: YieldOptions & {
+    shallowErrors?: boolean;
+    resetVersionOptions?: {
+        commonTimestamp?: string;
+        author?: string;
+    };
+    onVisit?: (entity: UserManagedElementShallowTransfer) => Promise<void>;
+}): Promise<{
+    project: IProjectShallowTransfer;
+    record: Record<EntityId, UserManagedElementShallowTransfer>;
+    order: EntityId[];
+    maps: Map<EntityId, EntityId>;
+}>;
+export declare function cloneProjectAsync(project: ProjectState, { enrich, shallowErrors, ...other }?: YieldOptions & {
+    enrich?: boolean;
+    shallowErrors?: boolean;
+    resetVersionOptions?: {
+        commonTimestamp?: string;
+        author?: string;
+    };
+    onVisit?: (entity: UserManagedElementShallowTransfer) => Promise<void>;
+}, parentContext?: IProjectInstanceParentContext): Promise<{
+    project: ProjectState;
+    maps: Map<EntityId, EntityId>;
+}>;
+export declare function cloneOntoExistingProject(source: ProjectState, target: ProjectState, changeSet?: ChangeSet | null, { enrich, shallowErrors, ...other }?: {
+    enrich?: boolean;
+    shallowErrors?: boolean;
+    resetVersionOptions?: {
+        commonTimestamp?: string;
+        author?: string;
+    };
+    onVisit?: (entity: UserManagedElementShallowTransfer) => void;
+}): {
+    project: ProjectState;
+    maps: Map<EntityId, EntityId>;
+    changeSet: ChangeSet | null;
+};
+export declare function cloneOntoExistingProjectAsync(source: ProjectState, target: ProjectState, changeSet?: ChangeSet | null, { enrich, shallowErrors, ...other }?: YieldOptions & {
+    enrich?: boolean;
+    shallowErrors?: boolean;
+    resetVersionOptions?: {
+        commonTimestamp?: string;
+        author?: string;
+    };
+    onVisit?: (entity: UserManagedElementShallowTransfer) => Promise<void>;
+}): Promise<{
+    project: ProjectState;
+    maps: Map<EntityId, EntityId>;
+    changeSet: ChangeSet | null;
+}>;
+export declare function initProject(data: IProjectTransfer, { enrich, shallowErrors, }?: {
+    enrich?: boolean;
+    shallowErrors?: boolean;
+}, parentContext?: IProjectInstanceParentContext): ProjectState;
+export declare function initProjectAsync(data: IProjectTransfer, { enrich, shallowErrors, yieldEvery, }?: {
+    enrich?: boolean;
+    shallowErrors?: boolean;
+    yieldEvery?: number;
+}, parentContext?: IProjectInstanceParentContext): Promise<ProjectState>;
+export declare function getProject(where: {
+    id: string;
+}, _options?: IGetProjectOptions, parentContext?: IProjectInstanceParentContext): Promise<ProjectState | null>;
+export declare function deleteRootProject(where: {
+    id: string;
+}): null;

package/dist/tree/state/types/actions.d.ts

@@ -0,0 +1,21 @@
+import { UserManagedElementShallowTransfer } from '../../../definitions';
+import { IRecordChangeSet } from '../change-set';
+import { DTOAction, ILiveMessageDTO } from '@elyx-code/definitions';
+
+export type PersistChangeSetEntityActionPayload = IRecordChangeSet<UserManagedElementShallowTransfer | null, UserManagedElementShallowTransfer> & {
+    isNewBranchHead: boolean;
+    branch: string;
+    chunkIndex?: number;
+    totalChunks?: number;
+};
+export type EntityActionPayload = PersistChangeSetEntityActionPayload;
+export interface IEntityActionRequestPayload<P extends {
+    [key: string]: any;
+} = EntityActionPayload> extends ILiveMessageDTO<DTOAction.PersistProjectChangeSet> {
+    action: DTOAction.PersistProjectChangeSet;
+    payload: P;
+}
+export type PersistChangeSetEntityActionRequestPayload = IEntityActionRequestPayload<PersistChangeSetEntityActionPayload>;
+export interface IEntityActionResponsePayload {
+    data: IRecordChangeSet<UserManagedElementShallowTransfer | null, UserManagedElementShallowTransfer>;
+}