@elyx-code/project-logic-tree 0.0.6863 → 0.0.6865

package/dist/index.d.ts

@@ -136,8 +136,19 @@ export declare class ActionDescriptorState extends UserManagedVersionedState imp
     subscribeToDependencies(): UserManagedEntityState;
     increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): ActionDescriptorState;
+    snapshot(): ActionDescriptorState;
+    /**
+     * 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 {ActionDescriptorState} snapshotInstance
+     * @returns {ActionDescriptorState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: ActionDescriptorState): ActionDescriptorState;
     recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ActionDescriptorState>;
-    restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ActionDescriptorState>>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<ActionDescriptorState>>;
     updateWithShallowTransfer(transfer: IActionDescriptorShallowTransfer, changeSet?: ChangeSet | null): ActionDescriptorState;
     updateWithGenerationTarget(transfer: Partial<IActionDescriptorGenerationTarget>, changeSet?: ChangeSet | null): ActionDescriptorState;
     hydrateAncestors(): IChangeSet<ActionDescriptorState>;
@@ -598,8 +609,19 @@ export declare class ArgumentDeclarationState extends UserManagedVersionedState
     subscribeToDependencies(): UserManagedEntityState;
     increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): ArgumentDeclarationState;
+    snapshot(): ArgumentDeclarationState;
+    /**
+     * 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 {ArgumentDeclarationState} snapshotInstance
+     * @returns {ArgumentDeclarationState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: ArgumentDeclarationState): ArgumentDeclarationState;
     recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ArgumentDeclarationState>;
-    restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ArgumentDeclarationState>>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<ArgumentDeclarationState>>;
     updateWithShallowTransfer(transfer: IArgumentDeclarationShallowTransfer, changeSet?: ChangeSet | null): ArgumentDeclarationState;
     updateWithGenerationTarget(transfer: Partial<IArgumentDeclarationGenerationTarget>, changeSet?: ChangeSet | null): ArgumentDeclarationState;
     hydrateAncestors(): IChangeSet<ArgumentDeclarationState>;
@@ -842,7 +864,7 @@ export declare enum BaseValueDescriptorIds {
          entity: UserManagedEntityState;
          field: string;
      }>;
-     knownVersions: Map<string, EntityState> | null;
+     knownVersions: Map<string, UserManagedEntityState> | null;
      activeVersion: boolean;
      initialized: boolean;
      startedInitialization: boolean;
@@ -900,8 +922,19 @@ export declare enum BaseValueDescriptorIds {
      subscribeToDependencies(): UserManagedEntityState;
      increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
      captureVersion(): BreakStatementState;
+     snapshot(): BreakStatementState;
+     /**
+      * 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 {BreakStatementState} snapshotInstance
+      * @returns {BreakStatementState} The snapshot instance with the current entity state applied to it
+      */
+     apply(snapshotInstance: BreakStatementState): BreakStatementState;
      recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<BreakStatementState>;
-     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<BreakStatementState>>;
+     restoreVersion(versionId: EntityVersion, options?: {
+         skipIfSameVersion?: boolean;
+     }): Promise<IChangeSet<BreakStatementState>>;
      updateWithShallowTransfer(transfer: IBreakStatementShallowTransfer, changeSet?: ChangeSet | null): BreakStatementState;
      updateWithGenerationTarget(transfer: Partial<IBreakStatementGenerationTarget>, changeSet?: ChangeSet | null): BreakStatementState;
      hydrateAncestors(): IChangeSet<BreakStatementState>;
@@ -9529,7 +9562,7 @@ export declare enum BaseValueDescriptorIds {
      CannotReSetValueOfConstantVariable = "cannot-reset-value-of-constant-variable",
      CannotConnectToOwnNode = "cannot-connect-to-own-node",
      VariableDeclarationCannotBeMovedToLowerScopeBecauseInstancesUsage = "variable-declaration-cannot-be-moved-to-lower-scope-because-instances-usage",
-     CannotChangeScopeBecauseItIsCalledByOtherEntities = "cannot-change-scope-because-it-is-called-by-other-entities",
+     CannotChangeScopeBecauseItIsAlreadyCalledByOtherEntitiesInDifferentScope = "cannot-change-scope-because-it-is-already-called-by-other-entities-in-different-scope",
      CannotChangeScopeBecauseItCallsOtherEntities = "cannot-change-scope-because-it-calls-other-entities",
      CalledByErrorMustBePassThroughCallable = "called-by-error-must-be-pass-through-callable",
      CalledByErrorCannotBeConnectedToEntitiesCalledByOwnSuccessBranch = "called-by-error-cannot-be-connected-to-entities-called-by-own-success-branch",
@@ -10093,7 +10126,7 @@ export declare enum BaseValueDescriptorIds {
          entity: UserManagedEntityState;
          field: string;
      }>;
-     knownVersions: Map<string, EntityState> | null;
+     knownVersions: Map<string, UserManagedEntityState> | null;
      activeVersion: boolean;
      initialized: boolean;
      startedInitialization: boolean;
@@ -10148,8 +10181,19 @@ export declare enum BaseValueDescriptorIds {
      subscribeToDependencies(): UserManagedEntityState;
      increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
      captureVersion(): ConditionState;
+     snapshot(): ConditionState;
+     /**
+      * 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 {ConditionState} snapshotInstance
+      * @returns {ConditionState} The snapshot instance with the current entity state applied to it
+      */
+     apply(snapshotInstance: ConditionState): ConditionState;
      recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ConditionState>;
-     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ConditionState>>;
+     restoreVersion(versionId: EntityVersion, options?: {
+         skipIfSameVersion?: boolean;
+     }): Promise<IChangeSet<ConditionState>>;
      updateWithShallowTransfer(transfer: IConditionShallowTransfer, changeSet?: ChangeSet | null): ConditionState;
      updateWithGenerationTarget(transfer: IConditionGenerationTarget, changeSet?: ChangeSet | null): ConditionState;
      hydrateAncestors(): IChangeSet<ConditionState>;
@@ -10227,7 +10271,9 @@ export declare enum BaseValueDescriptorIds {
  }
  export { conditionValidation }
 
- export declare const CONNECTABLE_TYPES: EntityType[][];
+ export declare const CONNECTABLE_TYPES: EntityType[];
+
+ export declare function connectEntitiesBasedOnConenctionType(sourceEntity: UserManagedEntityState, targetEntity: UserManagedEntityState, connectionType: ConnectionNodeType, changeSet: ChangeSet): void;
 
  export declare enum ConnectionNodeType {
      PropertyOut = "property-out",
@@ -10273,7 +10319,7 @@ export declare enum BaseValueDescriptorIds {
          entity: UserManagedEntityState;
          field: string;
      }>;
-     knownVersions: Map<string, EntityState> | null;
+     knownVersions: Map<string, UserManagedEntityState> | null;
      activeVersion: boolean;
      initialized: boolean;
      startedInitialization: boolean;
@@ -10331,8 +10377,19 @@ export declare enum BaseValueDescriptorIds {
      subscribeToDependencies(): UserManagedEntityState;
      increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
      captureVersion(): ContinueStatementState;
+     snapshot(): ContinueStatementState;
+     /**
+      * 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 {ContinueStatementState} snapshotInstance
+      * @returns {ContinueStatementState} The snapshot instance with the current entity state applied to it
+      */
+     apply(snapshotInstance: ContinueStatementState): ContinueStatementState;
      recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ContinueStatementState>;
-     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ContinueStatementState>>;
+     restoreVersion(versionId: EntityVersion, options?: {
+         skipIfSameVersion?: boolean;
+     }): Promise<IChangeSet<ContinueStatementState>>;
      updateWithShallowTransfer(transfer: IContinueStatementShallowTransfer, changeSet?: ChangeSet | null): ContinueStatementState;
      updateWithGenerationTarget(transfer: Partial<IContinueStatementGenerationTarget>, changeSet?: ChangeSet | null): ContinueStatementState;
      hydrateAncestors(): IChangeSet<ContinueStatementState>;
@@ -10913,7 +10970,7 @@ export declare enum BaseValueDescriptorIds {
          entity: UserManagedEntityState;
          field: string;
      }>;
-     knownVersions: Map<string, EntityState> | null;
+     knownVersions: Map<string, UserManagedEntityState> | null;
      activeVersion: boolean;
      initialized: boolean;
      startedInitialization: boolean;
@@ -10970,8 +11027,19 @@ export declare enum BaseValueDescriptorIds {
      subscribeToDependencies(): UserManagedEntityState;
      increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
      captureVersion(): DataTypeState;
+     snapshot(): DataTypeState;
+     /**
+      * 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 {DataTypeState} snapshotInstance
+      * @returns {DataTypeState} The snapshot instance with the current entity state applied to it
+      */
+     apply(snapshotInstance: DataTypeState): DataTypeState;
      recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<DataTypeState>;
-     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<DataTypeState>>;
+     restoreVersion(versionId: EntityVersion, options?: {
+         skipIfSameVersion?: boolean;
+     }): Promise<IChangeSet<DataTypeState>>;
      updateWithShallowTransfer(transfer: IDataTypeShallowTransfer, changeSet?: ChangeSet | null): DataTypeState;
      updateWithGenerationTarget(transfer: Partial<IDataTypeGenerationTarget>, changeSet?: ChangeSet | null): DataTypeState;
      hydrateAncestors(): IChangeSet<DataTypeState>;
@@ -11866,7 +11934,7 @@ export declare enum BaseValueDescriptorIds {
          entity: UserManagedEntityState;
          field: string;
      }>;
-     knownVersions: Map<string, EntityState> | null;
+     knownVersions: Map<string, UserManagedEntityState> | null;
      activeVersion: boolean;
      initialized: boolean;
      startedInitialization: boolean;
@@ -11938,8 +12006,19 @@ export declare enum BaseValueDescriptorIds {
      subscribeToDependencies(): UserManagedEntityState;
      increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
      captureVersion(): DefinitionEntityState;
+     snapshot(): DefinitionEntityState;
+     /**
+      * Given an instance of the same entity class type,
+      * it applies the current entity state to it by copying all of its data and entity references
+      *
+      * @param {DefinitionEntityState} snapshotInstance
+      * @returns {DefinitionEntityState} The snapshot instance with the current entity state applied to it
+      */
+     apply(snapshotInstance: DefinitionEntityState): DefinitionEntityState;
      recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<DefinitionEntityState>;
-     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<DefinitionEntityState>>;
+     restoreVersion(versionId: EntityVersion, options?: {
+         skipIfSameVersion?: boolean;
+     }): Promise<IChangeSet<DefinitionEntityState>>;
      updateWithShallowTransfer(transfer: IDefinitionEntityShallowTransfer, changeSet?: ChangeSet | null): DefinitionEntityState;
      updateWithGenerationTarget(transfer: Partial<IDefinitionEntityGenerationTarget>, changeSet?: ChangeSet | null): DefinitionEntityState;
      hydrateAncestors(): IChangeSet<DefinitionEntityState>;
@@ -14757,7 +14836,7 @@ export declare enum BaseValueDescriptorIds {
          entity: UserManagedEntityState;
          field: string;
      }>;
-     knownVersions: Map<string, EntityState> | null;
+     knownVersions: Map<string, UserManagedEntityState> | null;
      activeVersion: boolean;
      initialized: boolean;
      startedInitialization: boolean;
@@ -14812,8 +14891,19 @@ export declare enum BaseValueDescriptorIds {
      subscribeToDependencies(): UserManagedEntityState;
      increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
      captureVersion(): FunctionCallState;
+     snapshot(): FunctionCallState;
+     /**
+      * 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 {FunctionCallState} snapshotInstance
+      * @returns {FunctionCallState} The snapshot instance with the current entity state applied to it
+      */
+     apply(snapshotInstance: FunctionCallState): FunctionCallState;
      recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<FunctionCallState>;
-     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<FunctionCallState>>;
+     restoreVersion(versionId: EntityVersion, options?: {
+         skipIfSameVersion?: boolean;
+     }): Promise<IChangeSet<FunctionCallState>>;
      updateWithShallowTransfer(transfer: IFunctionCallShallowTransfer, changeSet?: ChangeSet | null): FunctionCallState;
      updateWithGenerationTarget(transfer: Partial<IFunctionCallGenerationTarget>, changeSet?: ChangeSet | null): FunctionCallState;
      hydrateAncestors(): IChangeSet<FunctionCallState>;
@@ -14927,7 +15017,7 @@ export declare enum BaseValueDescriptorIds {
          entity: UserManagedEntityState;
          field: string;
      }>;
-     knownVersions: Map<string, EntityState> | null;
+     knownVersions: Map<string, UserManagedEntityState> | null;
      activeVersion: boolean;
      initialized: boolean;
      startedInitialization: boolean;
@@ -14985,8 +15075,19 @@ export declare enum BaseValueDescriptorIds {
      subscribeToDependencies(): UserManagedEntityState;
      increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
      captureVersion(): FunctionDeclarationState;
+     snapshot(): FunctionDeclarationState;
+     /**
+      * 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 {FunctionDeclarationState} snapshotInstance
+      * @returns {FunctionDeclarationState} The snapshot instance with the current entity state applied to it
+      */
+     apply(snapshotInstance: FunctionDeclarationState): FunctionDeclarationState;
      recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<FunctionDeclarationState>;
-     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<FunctionDeclarationState>>;
+     restoreVersion(versionId: EntityVersion, options?: {
+         skipIfSameVersion?: boolean;
+     }): Promise<IChangeSet<FunctionDeclarationState>>;
      updateWithShallowTransfer(transfer: IFunctionDeclarationShallowTransfer, changeSet?: ChangeSet | null): FunctionDeclarationState;
      updateWithGenerationTarget(transfer: Partial<IFunctionDeclarationGenerationTarget>, changeSet?: ChangeSet | null): FunctionDeclarationState;
      hydrateAncestors(): IChangeSet<FunctionDeclarationState>;
@@ -20014,7 +20115,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -20070,8 +20171,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): GlobalEventState;
+      snapshot(): GlobalEventState;
+      /**
+       * 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 {GlobalEventState} snapshotInstance
+       * @returns {GlobalEventState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: GlobalEventState): GlobalEventState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<GlobalEventState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<GlobalEventState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<GlobalEventState>>;
       updateWithShallowTransfer(transfer: IGlobalEventShallowTransfer, changeSet?: ChangeSet | null): GlobalEventState;
       updateWithGenerationTarget(transfer: Partial<IGlobalEventGenerationTarget>, changeSet?: ChangeSet | null): GlobalEventState;
       hydrateAncestors(): IChangeSet<GlobalEventState>;
@@ -22085,7 +22197,7 @@ export declare enum BaseValueDescriptorIds {
       fixable: boolean;
       requiresCallConnectionTo: CallableEntityState | null;
       requiresCallConnectionToFrom: CallerEntityState | null;
-      nonAutofixableReasons: (CanvasEntityConnectionDisabledReason.VariableDeclarationCannotBeMovedToLowerScopeBecauseInstancesUsage | CanvasEntityConnectionDisabledReason.CannotChangeScopeBecauseItCallsOtherEntities | CanvasEntityConnectionDisabledReason.CannotChangeScopeBecauseItIsCalledByOtherEntities)[];
+      nonAutofixableReasons: (CanvasEntityConnectionDisabledReason.VariableDeclarationCannotBeMovedToLowerScopeBecauseInstancesUsage | CanvasEntityConnectionDisabledReason.CannotChangeScopeBecauseItCallsOtherEntities | CanvasEntityConnectionDisabledReason.CannotChangeScopeBecauseItIsAlreadyCalledByOtherEntitiesInDifferentScope)[];
   }
 
   export declare interface IIncompatibleParallelInCommonParentScope extends IScopeCompatibility {
@@ -22461,7 +22573,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -22519,8 +22631,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): InputMapState;
+      snapshot(): InputMapState;
+      /**
+       * 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 {InputMapState} snapshotInstance
+       * @returns {InputMapState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: InputMapState): InputMapState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<InputMapState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<InputMapState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<InputMapState>>;
       updateWithShallowTransfer(transfer: IInputMapShallowTransfer, changeSet?: ChangeSet | null): InputMapState;
       updateWithGenerationTarget(transfer: Partial<IInputMapGenerationTarget>, changeSet?: ChangeSet | null): InputMapState;
       hydrateAncestors(): IChangeSet<InputMapState>;
@@ -22608,7 +22731,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -22663,8 +22786,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): InstalledProjectState;
+      snapshot(): InstalledProjectState;
+      /**
+       * 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 {InstalledProjectState} snapshotInstance
+       * @returns {InstalledProjectState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: InstalledProjectState): InstalledProjectState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<InstalledProjectState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<InstalledProjectState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<InstalledProjectState>>;
       updateWithShallowTransfer(transfer: IInstalledProjectShallowTransfer, changeSet?: ChangeSet | null): InstalledProjectState;
       updateWithGenerationTarget(transfer: Partial<IInstalledProjectGenerationTarget>, changeSet?: ChangeSet | null): InstalledProjectState;
       hydrateAncestors(): IChangeSet<InstalledProjectState>;
@@ -22756,7 +22890,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -22812,8 +22946,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): InternalCallState;
+      snapshot(): InternalCallState;
+      /**
+       * 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 {InternalCallState} snapshotInstance
+       * @returns {InternalCallState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: InternalCallState): InternalCallState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<InternalCallState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<InternalCallState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<InternalCallState>>;
       updateWithShallowTransfer(transfer: IInternalCallShallowTransfer, changeSet?: ChangeSet | null): InternalCallState;
       updateWithGenerationTarget(transfer: Partial<IInternalCallGenerationTarget>, changeSet?: ChangeSet | null): InternalCallState;
       hydrateAncestors(): IChangeSet<InternalCallState>;
@@ -24394,6 +24539,12 @@ export declare enum BaseValueDescriptorIds {
 
   export declare const keyValuePrototype: IPrimitiveEntity;
 
+  export declare function layoutFromCallsFromGivenCaller(caller: CallerEntityState, changeSet: ChangeSet, options?: YieldOptions): Promise<void>;
+
+  export declare function layoutFullProjectCanvas(project: ProjectState, changeSet: ChangeSet, options?: YieldOptions): Promise<void>;
+
+  export declare function layoutOnlyModifiedEntryPointCanvas(project: ProjectState, changeSet: ChangeSet, options?: YieldOptions): Promise<void>;
+
   export declare const lengthDefault: ILiteralValueTransfer;
 
   export declare const LIST_OPERATIONS: {
@@ -25114,7 +25265,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -25173,8 +25324,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): LiteralValueState;
+      snapshot(): LiteralValueState;
+      /**
+       * 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 {LiteralValueState} snapshotInstance
+       * @returns {LiteralValueState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: LiteralValueState): LiteralValueState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<LiteralValueState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<LiteralValueState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<LiteralValueState>>;
       updateWithShallowTransfer(transfer: ILiteralValueShallowTransfer, changeSet?: ChangeSet | null): LiteralValueState;
       updateWithGenerationTarget(transfer: Partial<ILiteralValueGenerationTarget>, changeSet?: ChangeSet | null): LiteralValueState;
       hydrateAncestors(): IChangeSet<LiteralValueState>;
@@ -25277,7 +25439,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -25338,8 +25500,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): LoopState;
+      snapshot(): LoopState;
+      /**
+       * 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 {LoopState} snapshotInstance
+       * @returns {LoopState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: LoopState): LoopState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<LoopState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<LoopState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<LoopState>>;
       updateWithShallowTransfer(transfer: ILoopShallowTransfer, changeSet?: ChangeSet | null): LoopState;
       updateWithGenerationTarget(transfer: Partial<ILoopGenerationTarget>, changeSet?: ChangeSet | null): LoopState;
       hydrateAncestors(): IChangeSet<LoopState>;
@@ -29551,7 +29724,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -29606,8 +29779,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): OperationState;
+      snapshot(): OperationState;
+      /**
+       * 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 {OperationState} snapshotInstance
+       * @returns {OperationState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: OperationState): OperationState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<OperationState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<OperationState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<OperationState>>;
       updateWithShallowTransfer(transfer: IOperationShallowTransfer, changeSet?: ChangeSet | null): OperationState;
       updateWithGenerationTarget(transfer: Partial<IOperationGenerationTarget>, changeSet?: ChangeSet | null): OperationState;
       hydrateAncestors(): IChangeSet<OperationState>;
@@ -29740,7 +29924,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -29799,8 +29983,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): OutputMapState;
+      snapshot(): OutputMapState;
+      /**
+       * 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 {OutputMapState} snapshotInstance
+       * @returns {OutputMapState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: OutputMapState): OutputMapState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<OutputMapState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<OutputMapState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<OutputMapState>>;
       updateWithShallowTransfer(transfer: IOutputMapShallowTransfer, changeSet?: ChangeSet | null): OutputMapState;
       updateWithGenerationTarget(transfer: Partial<IOutputMapGenerationTarget>, changeSet?: ChangeSet | null): OutputMapState;
       hydrateAncestors(): IChangeSet<OutputMapState>;
@@ -30298,7 +30493,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -30393,8 +30588,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): ProjectState;
+      snapshot(): ProjectState;
+      /**
+       * 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 {ProjectState} snapshotInstance
+       * @returns {ProjectState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: ProjectState): ProjectState;
       recursiveCaptureUpstreamVersions(_sharedTimestamp: null | string): IChangeSet<ProjectState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ProjectState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<ProjectState>>;
       updateWithShallowTransfer(transfer: IProjectShallowTransfer, changeSet?: ChangeSet | null): ProjectState;
       updateWithGenerationTarget(transfer: Partial<IProjectGenerationTarget>, changeSet?: ChangeSet | null): ProjectState;
       hydrateAncestors(): IChangeSet<ProjectState>;
@@ -30622,7 +30828,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -30682,8 +30888,19 @@ export declare enum BaseValueDescriptorIds {
       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): Promise<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>;
@@ -31384,7 +31601,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -31442,8 +31659,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): ReturnStatementState;
+      snapshot(): ReturnStatementState;
+      /**
+       * 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 {ReturnStatementState} snapshotInstance
+       * @returns {ReturnStatementState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: ReturnStatementState): ReturnStatementState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ReturnStatementState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ReturnStatementState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<ReturnStatementState>>;
       updateWithShallowTransfer(transfer: IReturnStatementShallowTransfer, changeSet?: ChangeSet | null): ReturnStatementState;
       updateWithGenerationTarget(transfer: Partial<IReturnStatementGenerationTarget>, changeSet?: ChangeSet | null): ReturnStatementState;
       hydrateAncestors(): IChangeSet<ReturnStatementState>;
@@ -31625,7 +31853,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -31691,8 +31919,19 @@ export declare enum BaseValueDescriptorIds {
       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): Promise<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>;
@@ -33605,10 +33844,6 @@ export declare enum BaseValueDescriptorIds {
    */
   export declare function toCamelCase(str: string): string;
 
-  export declare function toCanvasFlatArray(project: ProjectState, changeSet: ChangeSet, options?: YieldOptions & {
-      forceAll?: boolean;
-  }): Promise<CanvasEntityState[]>;
-
   export declare function toEditorContext(extensionsRegistry: ExtensionsRegistry, editor: IEditor): DefaultEditorContext;
 
   export declare function toEntityState(entity: string | EntityState | IGenericReference | Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget, project: ProjectState): EntityState | null;
@@ -33753,7 +33988,7 @@ export declare enum BaseValueDescriptorIds {
 
   export declare function translateLogicErrorCodeWithEntityName(error: EntityError<SharedEntityErrorCode | EntityInstanceErrorCode | HTTPStatucCodeValidationErrorCodes | UUIDV4ValidationErrorCodes | CommonStringValidationErrorCodes>): string;
 
-  export declare function traverseChangeSet(changeSet: ChangeSet, onAdded: (entity: UserManagedEntityState) => void, onUpdated: (entity: UserManagedEntityState) => void, onRemoved: (entity: UserManagedEntityState) => void): void;
+  export declare function traverseChangeSet(changeSet: ChangeSet, onAdded: (entity: UserManagedEntityState) => void, onUpdated: (entity: UserManagedEntityState) => void, onRemoved: (entity: UserManagedEntityState) => void, onAffected: (entity: UserManagedEntityState) => void): void;
 
   export declare class Traverser {
       order: EntityId[];
@@ -34848,7 +35083,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -34904,8 +35139,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): ValueDescriptorState;
+      snapshot(): ValueDescriptorState;
+      /**
+       * 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 {ValueDescriptorState} snapshotInstance
+       * @returns {ValueDescriptorState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: ValueDescriptorState): ValueDescriptorState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ValueDescriptorState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ValueDescriptorState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<ValueDescriptorState>>;
       updateWithShallowTransfer(transfer: IValueDescriptorShallowTransfer, changeSet?: ChangeSet | null): ValueDescriptorState;
       updateWithGenerationTarget(transfer: Partial<IValueDescriptorGenerationTarget>, changeSet?: ChangeSet | null): ValueDescriptorState;
       hydrateAncestors(): IChangeSet<ValueDescriptorState>;
@@ -35071,7 +35317,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -35129,8 +35375,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): VariableDeclarationState;
+      snapshot(): VariableDeclarationState;
+      /**
+       * 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 {VariableDeclarationState} snapshotInstance
+       * @returns {VariableDeclarationState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: VariableDeclarationState): VariableDeclarationState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<VariableDeclarationState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<VariableDeclarationState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<VariableDeclarationState>>;
       updateWithShallowTransfer(transfer: IVariableDeclarationShallowTransfer, changeSet?: ChangeSet | null): VariableDeclarationState;
       updateWithGenerationTarget(transfer: Partial<IVariableDeclarationGenerationTarget>, changeSet?: ChangeSet | null): VariableDeclarationState;
       hydrateAncestors(): IChangeSet<VariableDeclarationState>;
@@ -35288,7 +35545,7 @@ export declare enum BaseValueDescriptorIds {
           entity: UserManagedEntityState;
           field: string;
       }>;
-      knownVersions: Map<string, EntityState> | null;
+      knownVersions: Map<string, UserManagedEntityState> | null;
       activeVersion: boolean;
       initialized: boolean;
       startedInitialization: boolean;
@@ -35347,8 +35604,19 @@ export declare enum BaseValueDescriptorIds {
       subscribeToDependencies(): UserManagedEntityState;
       increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
       captureVersion(): VariableInstanceState;
+      snapshot(): VariableInstanceState;
+      /**
+       * 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 {VariableInstanceState} snapshotInstance
+       * @returns {VariableInstanceState} The snapshot instance with the current entity state applied to it
+       */
+      apply(snapshotInstance: VariableInstanceState): VariableInstanceState;
       recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<VariableInstanceState>;
-      restoreVersion(versionId: EntityVersion): Promise<IChangeSet<VariableInstanceState>>;
+      restoreVersion(versionId: EntityVersion, options?: {
+          skipIfSameVersion?: boolean;
+      }): Promise<IChangeSet<VariableInstanceState>>;
       updateWithShallowTransfer(transfer: IVariableInstanceShallowTransfer, changeSet?: ChangeSet | null): VariableInstanceState;
       updateWithGenerationTarget(transfer: Partial<IVariableInstanceGenerationTarget>, changeSet?: ChangeSet | null): VariableInstanceState;
       hydrateAncestors(): IChangeSet<VariableInstanceState>;