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

package/dist/index.d.ts

@@ -136,6 +136,15 @@ 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, options?: {
         skipIfSameVersion?: boolean;
@@ -600,6 +609,15 @@ 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, options?: {
         skipIfSameVersion?: boolean;
@@ -904,6 +922,15 @@ 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, options?: {
          skipIfSameVersion?: boolean;
@@ -10154,6 +10181,15 @@ 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, options?: {
          skipIfSameVersion?: boolean;
@@ -10341,6 +10377,15 @@ 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, options?: {
          skipIfSameVersion?: boolean;
@@ -10982,6 +11027,15 @@ 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, options?: {
          skipIfSameVersion?: boolean;
@@ -11952,6 +12006,15 @@ 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, options?: {
          skipIfSameVersion?: boolean;
@@ -14828,6 +14891,15 @@ 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, options?: {
          skipIfSameVersion?: boolean;
@@ -15003,6 +15075,15 @@ 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, options?: {
          skipIfSameVersion?: boolean;
@@ -20090,6 +20171,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -22541,6 +22631,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -22687,6 +22786,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -22838,6 +22946,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -25207,6 +25324,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -25374,6 +25500,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -29644,6 +29779,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -29839,6 +29983,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -30435,6 +30588,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -30726,6 +30888,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -31488,6 +31659,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -31739,6 +31919,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -34950,6 +35139,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -35177,6 +35375,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;
@@ -35397,6 +35604,15 @@ 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, options?: {
           skipIfSameVersion?: boolean;