@elyx-code/project-logic-tree 0.0.6161 → 0.0.6162

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

@@ -1,14 +1,15 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IInstalledProject, IInstalledProjectGenerationTarget, IInstalledProjectReference, IInstalledProjectShallowTransfer, IInstalledProjectTransfer, IProjectReference, InstalledProjectTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { FunctionDeclarationState } from '../function-declaration';
 import { GlobalEventState } from '../global-event';
 import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../error';
-import { EntityState, IChangeSet } from '../types';
+import { EntityState, UserManagedEntityState } from '../types';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class InstalledProjectState extends VersionedState implements IInstalledProject, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, ChildEntityState {
+export declare class InstalledProjectState extends VersionedState implements IInstalledProject, UserManagedEntityStateTemplate, BaseState, BaseCanvasDraggableState, ChildEntityState {
     initialData: IInstalledProject | IInstalledProjectTransfer;
     readonly id: EntityId;
     readonly name: string;
@@ -22,9 +23,14 @@ export declare class InstalledProjectState extends VersionedState implements IIn
     parent: ProjectState;
     errors: EntityError[];
     project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     constructor(initialData: IInstalledProject | IInstalledProjectTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.InstalledProject;
@@ -52,36 +58,36 @@ export declare class InstalledProjectState extends VersionedState implements IIn
         errors: EntityGenerationError[];
         modifiedData: Partial<IInstalledProjectGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, _field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, _field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): InstalledProjectState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<InstalledProjectState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<InstalledProjectState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<InstalledProjectState>>;
     hydrateAncestors(): IChangeSet<InstalledProjectState>;
-    afterAllChildrenInitialized(): IChangeSet<InstalledProjectState>;
-    addSelfToProject(): IChangeSet<InstalledProjectState>;
-    setParent(parent: ProjectState): InstalledProjectState;
-    initChildren(): InstalledProjectState;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<InstalledProjectState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<InstalledProjectState>;
+    setParent(parent: ProjectState, changeSet?: ChangeSet | null): InstalledProjectState;
+    initChildren(changeSet?: ChangeSet | null): InstalledProjectState;
     subscribe(): InstalledProjectState;
     unsubscribe(): InstalledProjectState;
-    sync(data: Partial<IInstalledProject | IInstalledProjectTransfer | IInstalledProjectShallowTransfer>): InstalledProjectState;
+    metaSync(data: Partial<IInstalledProject | IInstalledProjectTransfer | IInstalledProjectShallowTransfer>, changeSet?: ChangeSet | null): InstalledProjectState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InstalledProjectState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IInstalledProjectShallowTransfer | null>;
-    remove({ ignoreUpstream: _, seenEntities, }?: {
+    remove({ ignoreUpstream: _ }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: InstalledProjectState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<InstalledProjectState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IInstalledProjectTransfer | IInstalledProjectReference;

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

@@ -204,14 +204,14 @@ export declare function getInstalledProjectSchema(): z.ZodObject<z.objectUtil.ex
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     functions: (Record<string, any> | {
         type: EntityType.FunctionDeclaration;
     })[];
     events: (Record<string, any> | {
         type: EntityType.GlobalEvent;
     })[];
+    x: number;
+    y: number;
 }, {
     description: string | null;
     implements: {
@@ -227,12 +227,12 @@ export declare function getInstalledProjectSchema(): z.ZodObject<z.objectUtil.ex
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     functions: (Record<string, any> | {
         type: EntityType.FunctionDeclaration;
     })[];
     events: (Record<string, any> | {
         type: EntityType.GlobalEvent;
     })[];
+    x: number;
+    y: number;
 }>;

package/dist/tree/state/internal-call/internal-call.d.ts

@@ -1,15 +1,19 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IInternalCall, IInternalCallGenerationTarget, IInternalCallReference, IInternalCallShallowTransfer, IInternalCallTransfer, InternalCallTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
+import { BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate } from '../base';
 import { ActionInputMapState } from '../input-map';
 import { ActionOutputMapState } from '../output-map';
-import { CallableEntityState, CallerEntityState, EntityState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState, ValueReadingEntityState, VariableState } from '../types';
+import { CallableEntityState, CallerEntityState, EntityState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState, ValueReadingEntityState, VariableState } from '../types';
 import { ProjectState } from '../project/project';
 import { FunctionDeclarationState } from '../function-declaration';
 import { EntityError, EntityGenerationError } from '../error';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class InternalCallState extends VersionedState implements IInternalCall, UserManagedEntityStateFunctionality, BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare enum InternalCallDependencyField {
+    Declaration = "declaration"
+}
+export declare class InternalCallState extends VersionedState implements IInternalCall, UserManagedEntityStateTemplate, BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: IInternalCall | IInternalCallTransfer;
     readonly id: EntityId;
     index: number;
@@ -27,9 +31,14 @@ export declare class InternalCallState extends VersionedState implements IIntern
     parent: VariableState;
     project: ProjectState;
     errors: EntityError[];
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IInternalCall | IInternalCallTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -58,12 +67,21 @@ export declare class InternalCallState extends VersionedState implements IIntern
         errors: EntityGenerationError[];
         modifiedData: Partial<IInternalCallGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): InternalCallState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<InternalCallState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<InternalCallState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<InternalCallState>>;
     hydrateAncestors(): IChangeSet<InternalCallState>;
-    afterAllChildrenInitialized(): IChangeSet<InternalCallState>;
-    addSelfToProject(): IChangeSet<InternalCallState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<InternalCallState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<InternalCallState>;
     get calledBy(): CallerEntityState[];
     removeInput(input: ActionInputMapState): InternalCallState;
     addInput(input: ActionInputMapState): InternalCallState;
@@ -71,38 +89,29 @@ export declare class InternalCallState extends VersionedState implements IIntern
     removeOutput(output: ActionOutputMapState): InternalCallState;
     addValueReader(entity: ValueReadingEntityState): InternalCallState;
     removeValueReader(valueReader: ValueReadingEntityState): InternalCallState;
-    addSuccessCaller(caller: PassThroughCallableEntityState): InternalCallState;
-    addErrorCaller(caller: PassThroughCallableEntityState): InternalCallState;
-    addEntryCaller(caller: EntryPointEntityState): InternalCallState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): InternalCallState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): InternalCallState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): InternalCallState;
     addErrorCall(call: CallableEntityState): InternalCallState;
     addSuccessCall(call: CallableEntityState): InternalCallState;
     removeCall(call: CallableEntityState): InternalCallState;
-    removeCaller(caller: CallerEntityState): InternalCallState;
-    setParent(parent: VariableState): InternalCallState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): InternalCallState;
+    setParent(parent: VariableState, changeSet?: ChangeSet | null): InternalCallState;
     setDeclaration(declaration: FunctionDeclarationState): InternalCallState;
-    initChildren(): InternalCallState;
+    initChildren(changeSet?: ChangeSet | null): InternalCallState;
     subscribe(): InternalCallState;
     unsubscribe(): InternalCallState;
-    sync(data: Partial<IInternalCall | IInternalCallTransfer | IInternalCallShallowTransfer>): InternalCallState;
+    metaSync(data: Partial<IInternalCall | IInternalCallTransfer | IInternalCallShallowTransfer>, changeSet?: ChangeSet | null): InternalCallState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InternalCallState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InternalCallState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InternalCallState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InternalCallState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<InternalCallState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IInternalCallShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: InternalCallState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<InternalCallState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IInternalCallTransfer | IInternalCallReference;
@@ -121,9 +130,9 @@ export declare class InternalCallState extends VersionedState implements IIntern
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
     clone(parent?: VariableState | null, newId?: string | null, subscribe?: boolean): InternalCallState;
-    removeUnrecognizedInputs(): IChangeSet<InternalCallState>;
-    removeUnrecognizedOutputs(): IChangeSet<InternalCallState>;
-    syncMissingFixedInputs(): IChangeSet<InternalCallState>;
-    syncMissingFixedOutputs(): IChangeSet<InternalCallState>;
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<InternalCallState>;
+    removeUnrecognizedOutputs(changeSet?: ChangeSet | null): IChangeSet<InternalCallState>;
+    syncMissingFixedInputs(changeSet?: ChangeSet | null): IChangeSet<InternalCallState>;
+    syncMissingFixedOutputs(changeSet?: ChangeSet | null): IChangeSet<InternalCallState>;
 }
 export type InternalCallPayloadUnion = InternalCallState | InternalCallTypesUnion;

package/dist/tree/state/literal-value/literal-value.d.ts

@@ -4,11 +4,11 @@ import { DefinitionEntityState } from '../definition-entity';
 import { DataTypeState } from '../data-type';
 import { InputMapState } from '../input-map';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { FunctionDeclarationState } from '../function-declaration';
 import { EntityError, EntityGenerationError } from '../error';
 import { OperationState } from '../operation';
-import { EntityState, EntityWithValueState, IChangeSet } from '../types';
+import { EntityState, EntityWithValueState, UserManagedEntityState } from '../types';
 import { PropertyState } from '../property';
 import { ArgumentDeclarationState } from '../argument-declaration';
 import { ReturnDeclarationState } from '../return-declaration';
@@ -17,23 +17,34 @@ import { ValueDescriptorState } from '../value-descriptor';
 import { OutputMapState } from '../output-map';
 import { VariableInstanceState } from '../variable-instance';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
+export declare enum LiteralValueDependencyField {
+    ValueAsTypeSingle = "value-as-type-single",
+    ValueAsTypeList = "value-as-type-list"
+}
 export type ValueAsTypeState = DefinitionEntityState | FunctionDeclarationState | OperationState;
-export declare class LiteralValueState extends VersionedState implements BaseState, UserManagedEntityStateFunctionality, ChildEntityState, ILiteralValue {
+export declare class LiteralValueState extends VersionedState implements BaseState, UserManagedEntityStateTemplate, ChildEntityState, ILiteralValue {
     initialData: ILiteralValue | ILiteralValueTransfer;
     readonly type: EntityType.LiteralValue;
     id: EntityId;
     name: PrimitiveTypes;
     autogeneration: ValueAutogenerationOptions | null;
     value: LiteralValueType;
-    valueAsType: ValueAsTypeState | ValueAsTypeState[] | null;
+    valueAsTypeSingle: ValueAsTypeState | null;
+    valueAsTypeList: ValueAsTypeState[] | null;
     errors: EntityError[];
     parent: DataTypeState | InputMapState | PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | VariableInstanceState | ValueDescriptorState | OutputMapState;
     standaloneParent: EntityWithValueState;
     project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     standalone: boolean;
     constructor(initialData: ILiteralValue | ILiteralValueTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -58,42 +69,43 @@ export declare class LiteralValueState extends VersionedState implements BaseSta
         errors: EntityGenerationError[];
         modifiedData: ILiteralValueGenerationTarget;
     };
+    get valueAsType(): ValueAsTypeState | ValueAsTypeState[] | null;
     validateGeneratedUpdate(data: Partial<ILiteralValueGenerationTarget>): {
         errors: EntityGenerationError[];
         modifiedData: Partial<ILiteralValueGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): LiteralValueState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<LiteralValueState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<LiteralValueState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<LiteralValueState>>;
     hydrateAncestors(): IChangeSet<LiteralValueState>;
-    afterAllChildrenInitialized(): IChangeSet<LiteralValueState>;
-    addSelfToProject(): IChangeSet<LiteralValueState>;
-    setParent(parent: DataTypeState | InputMapState | PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | VariableInstanceState | ValueDescriptorState | OutputMapState): LiteralValueState;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<LiteralValueState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<LiteralValueState>;
+    setParent(parent: DataTypeState | InputMapState | PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | VariableInstanceState | ValueDescriptorState | OutputMapState, changeSet?: ChangeSet | null): LiteralValueState;
     setStandaloneParent(parent: EntityWithValueState): LiteralValueState;
-    setValueAsType(valueAsType: ValueAsTypeState | ValueAsTypeState[] | null): LiteralValueState;
-    initChildren(): LiteralValueState;
+    setValueAsType(valueAsTypeSingle: ValueAsTypeState | ValueAsTypeState[] | null): LiteralValueState;
+    initChildren(changeSet?: ChangeSet | null): LiteralValueState;
     subscribe(): LiteralValueState;
     unsubscribe(): LiteralValueState;
-    sync(data: Partial<ILiteralValue | ILiteralValueTransfer | ILiteralValueShallowTransfer>): LiteralValueState;
+    metaSync(data: Partial<ILiteralValue | ILiteralValueTransfer | ILiteralValueShallowTransfer>, changeSet?: ChangeSet | null): LiteralValueState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LiteralValueState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LiteralValueState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LiteralValueState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LiteralValueState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LiteralValueState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<ILiteralValueShallowTransfer | null>;
-    remove({ ignoreUpstream: _, seenEntities, }?: {
+    remove({ ignoreUpstream: _ }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: LiteralValueState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<LiteralValueState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): ILiteralValueTransfer | ILiteralValueReference;