@aerokit/sdk 12.44.0

package/dist/cjs/bpm/process.js

@@ -0,0 +1,636 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var process_exports = {};
+__export(process_exports, {
+  Process: () => Process
+});
+module.exports = __toCommonJS(process_exports);
+var import_values = require("@aerokit/sdk/bpm/values");
+const BpmFacade = Java.type("org.eclipse.dirigible.components.api.bpm.BpmFacade");
+class Process {
+  /**
+   * Starts a new process instance for a given process definition key.
+   *
+   * @param key The process definition key (ID) of the process to start.
+   * @param businessKey An optional business key to associate with the process instance. Defaults to an empty string.
+   * @param parameters An optional map of process variables to pass to the process instance upon starting. Defaults to an empty object.
+   * @returns The unique ID of the newly started process instance.
+   */
+  static start(key, businessKey = "", parameters = {}) {
+    return BpmFacade.startProcess(key, businessKey, JSON.stringify(parameters));
+  }
+  /**
+   * Sets a human-readable name for an existing process instance.
+   *
+   * @param processInstanceId The ID of the process instance to update.
+   * @param name The new name for the process instance.
+   */
+  static setProcessInstanceName(processInstanceId, name) {
+    BpmFacade.setProcessInstanceName(processInstanceId, name);
+  }
+  /**
+   * Updates the business key of an existing process instance.
+   *
+   * @param processInstanceId The ID of the process instance to update.
+   * @param businessKey The new business key.
+   */
+  static updateBusinessKey(processInstanceId, businessKey) {
+    BpmFacade.updateBusinessKey(processInstanceId, businessKey);
+  }
+  /**
+   * Updates the business status of an existing process instance.
+   *
+   * @param processInstanceId The ID of the process instance to update.
+   * @param businessStatus The new business status.
+   */
+  static updateBusinessStatus(processInstanceId, businessStatus) {
+    BpmFacade.updateBusinessStatus(processInstanceId, businessStatus);
+  }
+  /**
+   * Retrieves the value of a specific variable from a process instance.
+   *
+   * @param processInstanceId The ID of the process instance.
+   * @param variableName The name of the variable to retrieve.
+   * @returns The value of the variable, or `null` if the variable does not exist. The type is `any` as it depends on the stored value.
+   */
+  static getVariable(processInstanceId, variableName) {
+    return BpmFacade.getVariable(processInstanceId, variableName);
+  }
+  /**
+   * Retrieves all variables associated with a process instance.
+   *
+   * @param processInstanceId The ID of the process instance.
+   * @returns An object containing all variables for the process instance, where keys are variable names and values are the variable values.
+   */
+  static getVariables(processInstanceId) {
+    return BpmFacade.getVariables(processInstanceId);
+  }
+  /**
+   * Sets or updates the value of a variable in a process instance.
+   *
+   * @param processInstanceId The ID of the process instance.
+   * @param variableName The name of the variable to set.
+   * @param value The new value for the variable. The type is `any` to accommodate different data types.
+   */
+  static setVariable(processInstanceId, variableName, value) {
+    BpmFacade.setVariable(processInstanceId, variableName, value);
+  }
+  /**
+   * Removes a variable from a process instance.
+   *
+   * @param processInstanceId The ID of the process instance.
+   * @param variableName The name of the variable to remove.
+   */
+  static removeVariable(processInstanceId, variableName) {
+    BpmFacade.removeVariable(processInstanceId, variableName);
+  }
+  /**
+   * Correlates a message event with a running process instance.
+   *
+   * @param processInstanceId The ID of the process instance to correlate the message to.
+   * @param messageName The name of the message event defined in the BPMN process.
+   * @param variables A map of variables (`Map<string, any>`) to pass along with the message event.
+   */
+  static correlateMessageEvent(processInstanceId, messageName, variables) {
+    BpmFacade.correlateMessageEvent(processInstanceId, messageName, import_values.Values.stringifyValuesMap(variables));
+  }
+  /**
+   * Retrieves the current execution context object, typically used within an execution listener or service task.
+   *
+   * @returns A new instance of the `ExecutionContext` containing details about the current process execution path.
+   */
+  static getExecutionContext() {
+    return new ExecutionContext();
+  }
+}
+class ExecutionContext {
+  constructor() {
+    this.execution = __context.get("execution");
+  }
+  /**
+   * Unique id of this path of execution that can be used as a handle to provide external signals back into the engine after wait states.
+   *
+   * @returns The unique ID of the current execution.
+   */
+  getId() {
+    return this.execution.getId();
+  }
+  /**
+   * Reference to the overall process instance.
+   * @returns The ID of the process instance.
+   */
+  getProcessInstanceId() {
+    return this.execution.getProcessInstanceId();
+  }
+  /**
+   * The 'root' process instance. When using call activity for example, the processInstance set will not always be the root. This method returns the topmost process instance.
+   *
+   * @returns The ID of the root process instance.
+   */
+  getRootProcessInstanceId() {
+    return this.execution.getRootProcessInstanceId();
+  }
+  /**
+   * Will contain the event name in case this execution is passed in for an {@link ExecutionListener}.
+   * @returns The current event name, or `null`/empty string if not executing an event listener.
+   */
+  getEventName() {
+    return this.execution.getEventName();
+  }
+  /**
+   * Sets the current event (typically when execution an {@link ExecutionListener}).
+   *
+   * @param eventName The name of the event.
+   */
+  setEventName(eventName) {
+    this.execution.setEventName(eventName);
+  }
+  /**
+   * The business key for the process instance this execution is associated with.
+   * @returns The business key.
+   */
+  getProcessInstanceBusinessKey() {
+    return this.execution.getProcessInstanceBusinessKey();
+  }
+  /**
+   * The business status for the process instance this execution is associated with.
+   * @returns The business status.
+   */
+  getProcessInstanceBusinessStatus() {
+    return this.execution.getProcessInstanceBusinessStatus();
+  }
+  /**
+   * The process definition key for the process instance this execution is associated with.
+   * @returns The process definition ID.
+   */
+  getProcessDefinitionId() {
+    return this.execution.getProcessDefinitionId();
+  }
+  /**
+   * If this execution runs in the context of a case and stage, this method returns it's closest parent stage instance id (the stage plan item instance id to be
+   * precise).
+   *
+   * @returns The stage instance id this execution belongs to or `null`, if this execution is not part of a case at all or is not a child element of a stage.
+   */
+  getPropagatedStageInstanceId() {
+    return this.execution.getPropagatedStageInstanceId();
+  }
+  /**
+   * Gets the id of the parent of this execution. If null, the execution represents a process-instance.
+   * @returns The parent execution ID, or `null`.
+   */
+  getParentId() {
+    return this.execution.getParentId();
+  }
+  /**
+   * Gets the id of the calling execution. If not null, the execution is part of a subprocess.
+   * @returns The super execution ID, or `null`.
+   */
+  getSuperExecutionId() {
+    return this.execution.getSuperExecutionId();
+  }
+  /**
+   * Gets the id of the current activity.
+   * @returns The current activity ID.
+   */
+  getCurrentActivityId() {
+    return this.execution.getCurrentActivityId();
+  }
+  /**
+   * Returns the tenant id, if any is set before on the process definition or process instance.
+   * @returns The tenant ID, or `null`/empty string.
+   */
+  getTenantId() {
+    return this.execution.getTenantId();
+  }
+  /**
+   * The BPMN element where the execution currently is at.
+   * @returns The current flow element object (type is Java object).
+   */
+  getCurrentFlowElement() {
+    return this.execution.getCurrentFlowElement();
+  }
+  /**
+   * Change the current BPMN element the execution is at.
+   * @param flowElement The new flow element object (Java type).
+   */
+  setCurrentFlowElement(flowElement) {
+    this.execution.setCurrentFlowElement(flowElement);
+  }
+  /**
+   * Returns the {@link FlowableListener} instance matching an {@link ExecutionListener} if currently an execution listener is being execution. Returns null otherwise.
+   * @returns The current Flowable Listener object (Java type), or `null`.
+   */
+  getCurrentFlowableListener() {
+    return this.execution.getCurrentFlowableListener();
+  }
+  /**
+   * Called when an {@link ExecutionListener} is being executed.
+   * @param currentListener The current listener object (Java type).
+   */
+  setCurrentFlowableListener(currentListener) {
+    this.execution.setCurrentFlowableListener(currentListener);
+  }
+  /**
+   * Create a snapshot read only delegate execution of this delegate execution.
+   *
+   * @returns A {@link ReadOnlyDelegateExecution} object (Java type).
+   */
+  snapshotReadOnly() {
+    return this.execution.snapshotReadOnly();
+  }
+  /**
+   * returns the parent of this execution, or null if there no parent.
+   * @returns The parent execution object (Java type), or `null`.
+   */
+  getParent() {
+    return this.execution.getParent();
+  }
+  /**
+   * returns the list of execution of which this execution the parent of.
+   * @returns An array of child execution objects (Java type).
+   */
+  getExecutions() {
+    return this.execution.getExecutions();
+  }
+  /**
+   * makes this execution active or inactive.
+   * @param isActive A boolean indicating whether the execution should be active.
+   */
+  setActive(isActive) {
+    this.execution.setActive(isActive);
+  }
+  /**
+   * returns whether this execution is currently active.
+   * @returns `true` if active, `false` otherwise.
+   */
+  isActive() {
+    return this.execution.isActive();
+  }
+  /**
+   * returns whether this execution has ended or not.
+   * @returns `true` if ended, `false` otherwise.
+   */
+  isEnded() {
+    return this.execution.isEnded();
+  }
+  /**
+   * changes the concurrent indicator on this execution.
+   * @param isConcurrent A boolean indicating whether the execution should be concurrent.
+   */
+  setConcurrent(isConcurrent) {
+    this.execution.setConcurrent(isConcurrent);
+  }
+  /**
+   * returns whether this execution is concurrent or not.
+   * @returns `true` if concurrent, `false` otherwise.
+   */
+  isConcurrent() {
+    return this.execution.isConcurrent();
+  }
+  /**
+   * returns whether this execution is a process instance or not.
+   * @returns `true` if it's a process instance, `false` otherwise.
+   */
+  isProcessInstanceType() {
+    return this.execution.isProcessInstanceType();
+  }
+  /**
+   * Inactivates this execution. This is useful for example in a join: the execution still exists, but it is not longer active.
+   */
+  inactivate() {
+    this.execution.inactivate();
+  }
+  /**
+   * Returns whether this execution is a scope.
+   * @returns `true` if it is a scope, `false` otherwise.
+   */
+  isScope() {
+    return this.execution.isScope();
+  }
+  /**
+   * Changes whether this execution is a scope or not.
+   * @param isScope A boolean indicating whether the execution should be a scope.
+   */
+  setScope(isScope) {
+    this.execution.setScope(isScope);
+  }
+  /**
+   * Returns whether this execution is the root of a multi instance execution.
+   * @returns `true` if it's a multi instance root, `false` otherwise.
+   */
+  isMultiInstanceRoot() {
+    return this.execution.isMultiInstanceRoot();
+  }
+  /**
+   * Changes whether this execution is a multi instance root or not.
+   * @param isMultiInstanceRoot A boolean indicating whether the execution is the root of a multi-instance execution.
+   */
+  setMultiInstanceRoot(isMultiInstanceRoot) {
+    this.execution.setMultiInstanceRoot(isMultiInstanceRoot);
+  }
+  /**
+   * Returns all variables. This will include all variables of parent scopes too.
+   * @returns A Map of variable names (`string`) to variable values (`any`).
+   */
+  getVariables() {
+    const variables = this.execution.getVariables();
+    for (const [key, value] of variables) {
+      variables.set(key, import_values.Values.parseValue(value));
+    }
+    return variables;
+  }
+  /**
+   * Returns all variables, as instances of the {@link VariableInstance} interface, which gives more information than only the value (type, execution id, etc.)
+   * @returns A Map of variable names (`string`) to {@link VariableInstance} objects (Java type).
+   */
+  getVariableInstances() {
+    return this.execution.getVariableInstances();
+  }
+  /**
+   * Returns the variable local to this scope only. So, in contrary to {@link #getVariables()}, the variables from the parent scope won't be returned.
+   * @returns A Map of variable names (`string`) to local variable values (`any`).
+   */
+  getVariablesLocal() {
+    const variablesLocal = this.execution.getVariablesLocal();
+    for (const [key, value] of variablesLocal) {
+      variablesLocal.set(key, import_values.Values.parseValue(value));
+    }
+    return variablesLocal;
+  }
+  /**
+   * Returns the variables local to this scope as instances of the {@link VariableInstance} interface, which provided additional information about the variable.
+   * @returns A Map of variable names (`string`) to local {@link VariableInstance} objects (Java type).
+   */
+  getVariableInstancesLocal() {
+    return this.execution.getVariableInstancesLocal();
+  }
+  /**
+   * Returns the variable value for one specific variable. Will look in parent scopes when the variable does not exist on this particular scope.
+   * @param variableName The name of the variable to retrieve.
+   * @returns The value of the variable (`any`), or `null` if not found.
+   */
+  getVariable(variableName) {
+    return import_values.Values.parseValue(this.execution.getVariable(variableName));
+  }
+  /**
+   * Similar to {@link #getVariable(String)}, but returns a {@link VariableInstance} instance, which contains more information than just the value.
+   * @param variableName The name of the variable to retrieve.
+   * @returns The {@link VariableInstance} object (Java type), or `null`.
+   */
+  getVariableInstance(variableName) {
+    return this.execution.getVariableInstance(variableName);
+  }
+  /**
+   * Returns the value for the specific variable and only checks this scope and not any parent scope.
+   * @param variableName The name of the local variable to retrieve.
+   * @returns The value of the local variable (`any`), or `null` if not found locally.
+   */
+  getVariableLocal(variableName) {
+    return import_values.Values.parseValue(this.execution.getVariableLocal(variableName));
+  }
+  /**
+   * Similar to {@link #getVariableLocal(String)}, but returns an instance of {@link VariableInstance}, which has some additional information beyond the value.
+   * @param variableName The name of the local variable to retrieve.
+   * @returns The local {@link VariableInstance} object (Java type), or `null`.
+   */
+  getVariableInstanceLocal(variableName) {
+    return this.execution.getVariableInstanceLocal(variableName);
+  }
+  /**
+   * Returns all the names of the variables for this scope and all parent scopes.
+   * @returns A Set of all variable names (`string`).
+   */
+  getVariableNames() {
+    const variableNames = /* @__PURE__ */ new Set();
+    for (const next of this.execution.getVariableNames().toArray()) {
+      variableNames.add(next);
+    }
+    return variableNames;
+  }
+  /**
+   * Returns all the names of the variables for this scope (no parent scopes).
+   * @returns A Set of local variable names (`string`).
+   */
+  getVariableNamesLocal() {
+    const variableNamesLocal = /* @__PURE__ */ new Set();
+    for (const next of this.execution.getVariableNamesLocal().toArray()) {
+      variableNamesLocal.add(next);
+    }
+    return variableNamesLocal;
+  }
+  /**
+   * Sets the variable with the provided name to the provided value. It checks parent scopes for an existing variable before setting on the current scope.
+   * @param variableName The name of the variable to be set.
+   * @param value The value of the variable to be set (`any`).
+   */
+  setVariable(variableName, value) {
+    this.execution.setVariable(variableName, import_values.Values.stringifyValue(value));
+  }
+  /**
+   * Similar to {@link #setVariable(String, Object)}, but the variable is set to this scope specifically (local variable).
+   * @param variableName The name of the variable to be set locally.
+   * @param value The value of the variable to be set (`any`).
+   * @returns The old value of the local variable (Java type), or `null`.
+   */
+  setVariableLocal(variableName, value) {
+    return this.execution.setVariableLocal(variableName, import_values.Values.stringifyValue(value));
+  }
+  /**
+   * Sets the provided variables to the variable scope, using the default scoping algorithm.
+   * @param variables A map of keys (`string`) and values (`any`) for the variables to be set.
+   */
+  setVariables(variables) {
+    for (const [key, value] of variables) {
+      variables.set(key, import_values.Values.stringifyValue(value));
+    }
+    this.execution.setVariables(variables);
+  }
+  /**
+   * Similar to {@link #setVariables(Map)}, but the variables are set on this scope specifically (local variables).
+   * @param variables A map of keys (`string`) and values (`any`) for the local variables to be set.
+   */
+  setVariablesLocal(variables) {
+    for (const [key, value] of variables) {
+      variables.set(key, import_values.Values.stringifyValue(value));
+    }
+    this.execution.setVariablesLocal(variables);
+  }
+  /**
+   * Returns whether this scope or any parent scope has variables.
+   * @returns `true` if variables exist in scope hierarchy, `false` otherwise.
+   */
+  hasVariables() {
+    return this.execution.hasVariables();
+  }
+  /**
+   * Returns whether this scope has variables.
+   * @returns `true` if local variables exist, `false` otherwise.
+   */
+  hasVariablesLocal() {
+    return this.execution.hasVariablesLocal();
+  }
+  /**
+   * Returns whether this scope or any parent scope has a specific variable.
+   * @param variableName The name of the variable to check.
+   * @returns `true` if the variable is found in the scope hierarchy, `false` otherwise.
+   */
+  hasVariable(variableName) {
+    return this.execution.hasVariable(variableName);
+  }
+  /**
+   * Returns whether this scope has a specific variable.
+   * @param variableName The name of the local variable to check.
+   * @returns `true` if the variable is found locally, `false` otherwise.
+   */
+  hasVariableLocal(variableName) {
+    return this.execution.hasVariableLocal(variableName);
+  }
+  /**
+   * Removes the variable from the process instance and creates a new HistoricVariableUpdate. Searches up the scope hierarchy.
+   * @param variableName The name of the variable to remove.
+   */
+  removeVariable(variableName) {
+    this.execution.removeVariable(variableName);
+  }
+  /**
+   * Removes the local variable and creates a new HistoricVariableUpdate.
+   * @param variableName The name of the local variable to remove.
+   */
+  removeVariableLocal(variableName) {
+    this.execution.removeVariableLocal(variableName);
+  }
+  /**
+   * Removes the variables and creates a new HistoricVariableUpdate for each of them. Searches up the scope hierarchy.
+   * @param variableNames An array of variable names (`string[]`) to remove.
+   */
+  removeVariables(variableNames) {
+    this.execution.removeVariables(variableNames);
+  }
+  /**
+   * Removes the local variables and creates a new HistoricVariableUpdate for each of them.
+   * @param variableNames An array of local variable names (`string[]`) to remove.
+   */
+  removeVariablesLocal(variableNames) {
+    this.execution.removeVariablesLocal(variableNames);
+  }
+  /**
+   * Sets a transient variable using the default scoping mechanism (up the hierarchy). Transient variables have no history and are cleared at wait states.
+   * @param variableName The name of the transient variable.
+   * @param variableValue The value of the transient variable (`any`).
+   */
+  setTransientVariable(variableName, variableValue) {
+    this.execution.setTransientVariable(variableName, import_values.Values.stringifyValue(variableValue));
+  }
+  /**
+   * Sets a local transient variable. Transient variables have no history and are cleared at wait states.
+   * @param variableName The name of the local transient variable.
+   * @param variableValue The value of the local transient variable (`any`).
+   */
+  setTransientVariableLocal(variableName, variableValue) {
+    this.execution.setTransientVariableLocal(variableName, import_values.Values.stringifyValue(variableValue));
+  }
+  /**
+   * Sets multiple transient variables using the default scoping mechanism (up the hierarchy).
+   * @param transientVariables A map of keys (`string`) and values (`any`) for the transient variables to be set.
+   */
+  setTransientVariables(transientVariables) {
+    for (const [key, value] of transientVariables) {
+      transientVariables.set(key, import_values.Values.stringifyValue(value));
+    }
+    this.execution.setTransientVariables(transientVariables);
+  }
+  /**
+   * Retrieves the value of a transient variable, searching up the parent scopes.
+   * @param variableName The name of the transient variable to retrieve.
+   * @returns The value of the transient variable (`any`), or `null` if not found.
+   */
+  getTransientVariable(variableName) {
+    return import_values.Values.parseValue(this.execution.getTransientVariable(variableName));
+  }
+  /**
+   * Retrieves all transient variables in the current scope hierarchy.
+   * @returns A Map of transient variable names (`string`) to values (`any`).
+   */
+  getTransientVariables() {
+    const transientVariables = this.execution.getTransientVariables();
+    for (const [key, value] of transientVariables) {
+      transientVariables.set(key, import_values.Values.parseValue(value));
+    }
+    return transientVariables;
+  }
+  /**
+   * Sets multiple local transient variables.
+   * @param transientVariables A map of keys (`string`) and values (`any`) for the local transient variables to be set.
+   */
+  setTransientVariablesLocal(transientVariables) {
+    for (const [key, value] of transientVariables) {
+      transientVariables.set(key, import_values.Values.stringifyValue(value));
+    }
+    this.execution.setTransientVariablesLocal(transientVariables);
+  }
+  /**
+   * Retrieves the value of a local transient variable.
+   * @param variableName The name of the local transient variable to retrieve.
+   * @returns The value of the local transient variable (`any`), or `null` if not found.
+   */
+  getTransientVariableLocal(variableName) {
+    return import_values.Values.parseValue(this.execution.getTransientVariableLocal(variableName));
+  }
+  /**
+   * Retrieves all local transient variables.
+   * @returns A Map of local transient variable names (`string`) to values (`any`).
+   */
+  getTransientVariablesLocal() {
+    const transientVariablesLocal = this.execution.getTransientVariablesLocal();
+    for (const [key, value] of transientVariablesLocal) {
+      transientVariablesLocal.set(key, import_values.Values.parseValue(value));
+    }
+    return transientVariablesLocal;
+  }
+  /**
+   * Removes a specific local transient variable.
+   * @param variableName The name of the local transient variable to remove.
+   */
+  removeTransientVariableLocal(variableName) {
+    this.execution.removeTransientVariableLocal(variableName);
+  }
+  /**
+   * Removes a specific transient variable, searching up the scope hierarchy.
+   * @param variableName The name of the transient variable to remove.
+   */
+  removeTransientVariable(variableName) {
+    this.execution.removeTransientVariable(variableName);
+  }
+  /**
+   * Remove all transient variables of this scope and its parent scopes.
+   */
+  removeTransientVariables() {
+    this.execution.removeTransientVariables();
+  }
+  /**
+   * Removes all local transient variables.
+   */
+  removeTransientVariablesLocal() {
+    this.execution.removeTransientVariablesLocal();
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Process;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/bpm/process.ts"],
  "sourcesContent": ["/**\n * API Process\n * * Provides methods for interacting with process instances,\n * including starting, updating metadata, and managing variables.\n */\n\nimport { Values } from \"@aerokit/sdk/bpm/values\";\n\nconst BpmFacade = Java.type(\"org.eclipse.dirigible.components.api.bpm.BpmFacade\");\n\nexport class Process {\n\n\t/**\n\t * Starts a new process instance for a given process definition key.\n\t *\n\t * @param key The process definition key (ID) of the process to start.\n\t * @param businessKey An optional business key to associate with the process instance. Defaults to an empty string.\n\t * @param parameters An optional map of process variables to pass to the process instance upon starting. Defaults to an empty object.\n\t * @returns The unique ID of the newly started process instance.\n\t */\n\tpublic static start(key: string, businessKey: string = '', parameters: { [key: string]: any } = {}): string {\n\t\treturn BpmFacade.startProcess(key, businessKey, JSON.stringify(parameters));\n\t}\n\n\t/**\n\t * Sets a human-readable name for an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param name The new name for the process instance.\n\t */\n\tpublic static setProcessInstanceName(processInstanceId: string, name: string): void {\n\t\tBpmFacade.setProcessInstanceName(processInstanceId, name);\n\t}\n\n\t/**\n\t * Updates the business key of an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param businessKey The new business key.\n\t */\n\tpublic static updateBusinessKey(processInstanceId: string, businessKey: string): void {\n\t\tBpmFacade.updateBusinessKey(processInstanceId, businessKey);\n\t}\n\n\t/**\n\t * Updates the business status of an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param businessStatus The new business status.\n\t */\n\tpublic static updateBusinessStatus(processInstanceId: string, businessStatus: string): void {\n\t\tBpmFacade.updateBusinessStatus(processInstanceId, businessStatus);\n\t}\n\n\t/**\n\t * Retrieves the value of a specific variable from a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The value of the variable, or `null` if the variable does not exist. The type is `any` as it depends on the stored value.\n\t */\n\tpublic static getVariable(processInstanceId: string, variableName: string): any {\n\t\treturn BpmFacade.getVariable(processInstanceId, variableName);\n\t}\n\n\t/**\n\t * Retrieves all variables associated with a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @returns An object containing all variables for the process instance, where keys are variable names and values are the variable values.\n\t */\n\tpublic static getVariables(processInstanceId: string): any {\n\t\treturn BpmFacade.getVariables(processInstanceId);\n\t}\n\n\t/**\n\t * Sets or updates the value of a variable in a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to set.\n\t * @param value The new value for the variable. The type is `any` to accommodate different data types.\n\t */\n\tpublic static setVariable(processInstanceId: string, variableName: string, value: any): void {\n\t\tBpmFacade.setVariable(processInstanceId, variableName, value);\n\t}\n\n\t/**\n\t * Removes a variable from a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to remove.\n\t */\n\tpublic static removeVariable(processInstanceId: string, variableName: string): void {\n\t\tBpmFacade.removeVariable(processInstanceId, variableName);\n\t}\n\n\t/**\n\t * Correlates a message event with a running process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to correlate the message to.\n\t * @param messageName The name of the message event defined in the BPMN process.\n\t * @param variables A map of variables (`Map<string, any>`) to pass along with the message event.\n\t */\n\tpublic static correlateMessageEvent(processInstanceId: string, messageName: string, variables: Map<string, any>): void {\n\t\tBpmFacade.correlateMessageEvent(processInstanceId, messageName, Values.stringifyValuesMap(variables));\n\t}\n\n\t/**\n\t * Retrieves the current execution context object, typically used within an execution listener or service task.\n\t *\n\t * @returns A new instance of the `ExecutionContext` containing details about the current process execution path.\n\t */\n\tpublic static getExecutionContext() {\n\t\treturn new ExecutionContext();\n\t}\n}\n\n/**\n * ExecutionContext object\n * * Provides detailed information and control over the current process execution path.\n */\nclass ExecutionContext {\n\n\tprivate execution: any;\n\n\tconstructor() {\n\t\tthis.execution = __context.get('execution');\n\t}\n\n\t/**\n\t * Unique id of this path of execution that can be used as a handle to provide external signals back into the engine after wait states.\n\t *\n\t * @returns The unique ID of the current execution.\n\t */\n\tpublic getId(): string {\n\t\treturn this.execution.getId();\n\t}\n\n\t/**\n\t * Reference to the overall process instance.\n\t * @returns The ID of the process instance.\n\t */\n\tpublic getProcessInstanceId(): string {\n\t\treturn this.execution.getProcessInstanceId();\n\t}\n\n\t/**\n\t * The 'root' process instance. When using call activity for example, the processInstance set will not always be the root. This method returns the topmost process instance.\n\t *\n\t * @returns The ID of the root process instance.\n\t */\n\tpublic getRootProcessInstanceId(): string {\n\t\treturn this.execution.getRootProcessInstanceId();\n\t}\n\n\t/**\n\t * Will contain the event name in case this execution is passed in for an {@link ExecutionListener}.\n\t * @returns The current event name, or `null`/empty string if not executing an event listener.\n\t */\n\tpublic getEventName(): string {\n\t\treturn this.execution.getEventName();\n\t}\n\n\t/**\n\t * Sets the current event (typically when execution an {@link ExecutionListener}).\n\t *\n\t * @param eventName The name of the event.\n\t */\n\tpublic setEventName(eventName: string): void {\n\t\tthis.execution.setEventName(eventName);\n\t}\n\n\t/**\n\t * The business key for the process instance this execution is associated with.\n\t * @returns The business key.\n\t */\n\tpublic getProcessInstanceBusinessKey(): string {\n\t\treturn this.execution.getProcessInstanceBusinessKey();\n\t}\n\n\t/**\n\t * The business status for the process instance this execution is associated with.\n\t * @returns The business status.\n\t */\n\tpublic getProcessInstanceBusinessStatus(): string {\n\t\treturn this.execution.getProcessInstanceBusinessStatus();\n\t}\n\n\t/**\n\t * The process definition key for the process instance this execution is associated with.\n\t * @returns The process definition ID.\n\t */\n\tpublic getProcessDefinitionId(): string {\n\t\treturn this.execution.getProcessDefinitionId();\n\t}\n\n\t/**\n\t * If this execution runs in the context of a case and stage, this method returns it's closest parent stage instance id (the stage plan item instance id to be\n\t * precise).\n\t *\n\t * @returns The stage instance id this execution belongs to or `null`, if this execution is not part of a case at all or is not a child element of a stage.\n\t */\n\tpublic getPropagatedStageInstanceId(): string {\n\t\treturn this.execution.getPropagatedStageInstanceId();\n\t}\n\n\t/**\n\t * Gets the id of the parent of this execution. If null, the execution represents a process-instance.\n\t * @returns The parent execution ID, or `null`.\n\t */\n\tpublic getParentId(): string {\n\t\treturn this.execution.getParentId();\n\t}\n\n\t/**\n\t * Gets the id of the calling execution. If not null, the execution is part of a subprocess.\n\t * @returns The super execution ID, or `null`.\n\t */\n\tpublic getSuperExecutionId(): string {\n\t\treturn this.execution.getSuperExecutionId();\n\t}\n\n\t/**\n\t * Gets the id of the current activity.\n\t * @returns The current activity ID.\n\t */\n\tpublic getCurrentActivityId(): string {\n\t\treturn this.execution.getCurrentActivityId();\n\t}\n\n\t/**\n\t * Returns the tenant id, if any is set before on the process definition or process instance.\n\t * @returns The tenant ID, or `null`/empty string.\n\t */\n\tpublic getTenantId(): string {\n\t\treturn this.execution.getTenantId();\n\t}\n\n\t/**\n\t * The BPMN element where the execution currently is at.\n\t * @returns The current flow element object (type is Java object).\n\t */\n\tpublic getCurrentFlowElement(): any {\n\t\treturn this.execution.getCurrentFlowElement();\n\t}\n\n\t/**\n\t * Change the current BPMN element the execution is at.\n\t * @param flowElement The new flow element object (Java type).\n\t */\n\tpublic setCurrentFlowElement(flowElement: any): void {\n\t\tthis.execution.setCurrentFlowElement(flowElement);\n\t}\n\n\t/**\n\t * Returns the {@link FlowableListener} instance matching an {@link ExecutionListener} if currently an execution listener is being execution. Returns null otherwise.\n\t * @returns The current Flowable Listener object (Java type), or `null`.\n\t */\n\tpublic getCurrentFlowableListener(): any {\n\t\treturn this.execution.getCurrentFlowableListener();\n\t}\n\n\t/**\n\t * Called when an {@link ExecutionListener} is being executed.\n\t * @param currentListener The current listener object (Java type).\n\t */\n\tpublic setCurrentFlowableListener(currentListener: any): void {\n\t\tthis.execution.setCurrentFlowableListener(currentListener);\n\t}\n\n\t/**\n\t * Create a snapshot read only delegate execution of this delegate execution.\n\t *\n\t * @returns A {@link ReadOnlyDelegateExecution} object (Java type).\n\t */\n\tpublic snapshotReadOnly(): any {\n\t\treturn this.execution.snapshotReadOnly();\n\t}\n\n\t/**\n\t * returns the parent of this execution, or null if there no parent.\n\t * @returns The parent execution object (Java type), or `null`.\n\t */\n\tpublic getParent(): any {\n\t\treturn this.execution.getParent();\n\t}\n\n\t/**\n\t * returns the list of execution of which this execution the parent of.\n\t * @returns An array of child execution objects (Java type).\n\t */\n\tpublic getExecutions(): any[] {\n\t\treturn this.execution.getExecutions();\n\t}\n\n\t/**\n\t * makes this execution active or inactive.\n\t * @param isActive A boolean indicating whether the execution should be active.\n\t */\n\tpublic setActive(isActive: boolean): void {\n\t\tthis.execution.setActive(isActive);\n\t}\n\n\t/**\n\t * returns whether this execution is currently active.\n\t * @returns `true` if active, `false` otherwise.\n\t */\n\tpublic isActive(): boolean {\n\t\treturn this.execution.isActive();\n\t}\n\n\t/**\n\t * returns whether this execution has ended or not.\n\t * @returns `true` if ended, `false` otherwise.\n\t */\n\tpublic isEnded(): boolean {\n\t\treturn this.execution.isEnded();\n\t}\n\n\t/**\n\t * changes the concurrent indicator on this execution.\n\t * @param isConcurrent A boolean indicating whether the execution should be concurrent.\n\t */\n\tpublic setConcurrent(isConcurrent: boolean): void {\n\t\tthis.execution.setConcurrent(isConcurrent);\n\t}\n\n\t/**\n\t * returns whether this execution is concurrent or not.\n\t * @returns `true` if concurrent, `false` otherwise.\n\t */\n\tpublic isConcurrent(): boolean {\n\t\treturn this.execution.isConcurrent();\n\t}\n\n\t/**\n\t * returns whether this execution is a process instance or not.\n\t * @returns `true` if it's a process instance, `false` otherwise.\n\t */\n\tpublic isProcessInstanceType(): boolean {\n\t\treturn this.execution.isProcessInstanceType();\n\t}\n\n\t/**\n\t * Inactivates this execution. This is useful for example in a join: the execution still exists, but it is not longer active.\n\t */\n\tpublic inactivate(): void {\n\t\tthis.execution.inactivate();\n\t}\n\n\t/**\n\t * Returns whether this execution is a scope.\n\t * @returns `true` if it is a scope, `false` otherwise.\n\t */\n\tpublic isScope(): boolean {\n\t\treturn this.execution.isScope();\n\t}\n\n\t/**\n\t * Changes whether this execution is a scope or not.\n\t * @param isScope A boolean indicating whether the execution should be a scope.\n\t */\n\tpublic setScope(isScope: boolean): void {\n\t\tthis.execution.setScope(isScope);\n\t}\n\n\t/**\n\t * Returns whether this execution is the root of a multi instance execution.\n\t * @returns `true` if it's a multi instance root, `false` otherwise.\n\t */\n\tpublic isMultiInstanceRoot(): boolean {\n\t\treturn this.execution.isMultiInstanceRoot();\n\t}\n\n\t/**\n\t * Changes whether this execution is a multi instance root or not.\n\t * @param isMultiInstanceRoot A boolean indicating whether the execution is the root of a multi-instance execution.\n\t */\n\tpublic setMultiInstanceRoot(isMultiInstanceRoot: boolean): void {\n\t\tthis.execution.setMultiInstanceRoot(isMultiInstanceRoot);\n\t}\n\n\t/**\n\t * Returns all variables. This will include all variables of parent scopes too.\n\t * @returns A Map of variable names (`string`) to variable values (`any`).\n\t */\n\tpublic getVariables(): Map<string, any> {\n\t\tconst variables = this.execution.getVariables();\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn variables;\n\t}\n\n\t/**\n\t * Returns all variables, as instances of the {@link VariableInstance} interface, which gives more information than only the value (type, execution id, etc.)\n\t * @returns A Map of variable names (`string`) to {@link VariableInstance} objects (Java type).\n\t */\n\tpublic getVariableInstances(): Map<string, any> {\n\t\treturn this.execution.getVariableInstances();\n\t}\n\n\t/**\n\t * Returns the variable local to this scope only. So, in contrary to {@link #getVariables()}, the variables from the parent scope won't be returned.\n\t * @returns A Map of variable names (`string`) to local variable values (`any`).\n\t */\n\tpublic getVariablesLocal(): Map<string, any> {\n\t\tconst variablesLocal = this.execution.getVariablesLocal();\n\t\tfor (const [key, value] of variablesLocal) {\n\t\t\tvariablesLocal.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn variablesLocal;\n\t}\n\n\t/**\n\t * Returns the variables local to this scope as instances of the {@link VariableInstance} interface, which provided additional information about the variable.\n\t * @returns A Map of variable names (`string`) to local {@link VariableInstance} objects (Java type).\n\t */\n\tpublic getVariableInstancesLocal(): Map<string, any> {\n\t\treturn this.execution.getVariableInstancesLocal();\n\t}\n\n\t/**\n\t * Returns the variable value for one specific variable. Will look in parent scopes when the variable does not exist on this particular scope.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The value of the variable (`any`), or `null` if not found.\n\t */\n\tpublic getVariable(variableName: string): any {\n\t\treturn Values.parseValue(this.execution.getVariable(variableName));\n\t}\n\n\t/**\n\t * Similar to {@link #getVariable(String)}, but returns a {@link VariableInstance} instance, which contains more information than just the value.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The {@link VariableInstance} object (Java type), or `null`.\n\t */\n\tpublic getVariableInstance(variableName: string): any {\n\t\treturn this.execution.getVariableInstance(variableName);\n\t}\n\n\t/**\n\t * Returns the value for the specific variable and only checks this scope and not any parent scope.\n\t * @param variableName The name of the local variable to retrieve.\n\t * @returns The value of the local variable (`any`), or `null` if not found locally.\n\t */\n\tpublic getVariableLocal(variableName: string): any {\n\t\treturn Values.parseValue(this.execution.getVariableLocal(variableName));\n\t}\n\n\t/**\n\t * Similar to {@link #getVariableLocal(String)}, but returns an instance of {@link VariableInstance}, which has some additional information beyond the value.\n\t * @param variableName The name of the local variable to retrieve.\n\t * @returns The local {@link VariableInstance} object (Java type), or `null`.\n\t */\n\tpublic getVariableInstanceLocal(variableName: string): any {\n\t\treturn this.execution.getVariableInstanceLocal(variableName);\n\t}\n\n\t/**\n\t * Returns all the names of the variables for this scope and all parent scopes.\n\t * @returns A Set of all variable names (`string`).\n\t */\n\tpublic getVariableNames(): Set<string> {\n\t\tconst variableNames = new Set<string>();\n\t\tfor (const next of this.execution.getVariableNames().toArray()) {\n\t\t\tvariableNames.add(next);\n\t\t}\n\t\treturn variableNames;\n\t}\n\n\t/**\n\t * Returns all the names of the variables for this scope (no parent scopes).\n\t * @returns A Set of local variable names (`string`).\n\t */\n\tpublic getVariableNamesLocal(): Set<string> {\n\t\tconst variableNamesLocal = new Set<string>();\n\t\tfor (const next of this.execution.getVariableNamesLocal().toArray()) {\n\t\t\tvariableNamesLocal.add(next);\n\t\t}\n\t\treturn variableNamesLocal;\n\t}\n\n\t/**\n\t * Sets the variable with the provided name to the provided value. It checks parent scopes for an existing variable before setting on the current scope.\n\t * @param variableName The name of the variable to be set.\n\t * @param value The value of the variable to be set (`any`).\n\t */\n\tpublic setVariable(variableName: string, value: any): void {\n\t\tthis.execution.setVariable(variableName, Values.stringifyValue(value));\n\t}\n\n\t/**\n\t * Similar to {@link #setVariable(String, Object)}, but the variable is set to this scope specifically (local variable).\n\t * @param variableName The name of the variable to be set locally.\n\t * @param value The value of the variable to be set (`any`).\n\t * @returns The old value of the local variable (Java type), or `null`.\n\t */\n\tpublic setVariableLocal(variableName: string, value: any): any {\n\t\treturn this.execution.setVariableLocal(variableName, Values.stringifyValue(value));\n\t}\n\n\t/**\n\t * Sets the provided variables to the variable scope, using the default scoping algorithm.\n\t * @param variables A map of keys (`string`) and values (`any`) for the variables to be set.\n\t */\n\tpublic setVariables(variables: Map<string, any>): void {\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.execution.setVariables(variables);\n\t}\n\n\t/**\n\t * Similar to {@link #setVariables(Map)}, but the variables are set on this scope specifically (local variables).\n\t * @param variables A map of keys (`string`) and values (`any`) for the local variables to be set.\n\t */\n\tpublic setVariablesLocal(variables: Map<string, any>): void {\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.execution.setVariablesLocal(variables);\n\t}\n\n\t/**\n\t * Returns whether this scope or any parent scope has variables.\n\t * @returns `true` if variables exist in scope hierarchy, `false` otherwise.\n\t */\n\tpublic hasVariables(): boolean {\n\t\treturn this.execution.hasVariables();\n\t}\n\n\t/**\n\t * Returns whether this scope has variables.\n\t * @returns `true` if local variables exist, `false` otherwise.\n\t */\n\tpublic hasVariablesLocal(): boolean {\n\t\treturn this.execution.hasVariablesLocal();\n\t}\n\n\t/**\n\t * Returns whether this scope or any parent scope has a specific variable.\n\t * @param variableName The name of the variable to check.\n\t * @returns `true` if the variable is found in the scope hierarchy, `false` otherwise.\n\t */\n\tpublic hasVariable(variableName: string): boolean {\n\t\treturn this.execution.hasVariable(variableName);\n\t}\n\n\t/**\n\t * Returns whether this scope has a specific variable.\n\t * @param variableName The name of the local variable to check.\n\t * @returns `true` if the variable is found locally, `false` otherwise.\n\t */\n\tpublic hasVariableLocal(variableName: string): boolean {\n\t\treturn this.execution.hasVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes the variable from the process instance and creates a new HistoricVariableUpdate. Searches up the scope hierarchy.\n\t * @param variableName The name of the variable to remove.\n\t */\n\tpublic removeVariable(variableName: string): void {\n\t\tthis.execution.removeVariable(variableName);\n\t}\n\n\t/**\n\t * Removes the local variable and creates a new HistoricVariableUpdate.\n\t * @param variableName The name of the local variable to remove.\n\t */\n\tpublic removeVariableLocal(variableName: string): void {\n\t\tthis.execution.removeVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes the variables and creates a new HistoricVariableUpdate for each of them. Searches up the scope hierarchy.\n\t * @param variableNames An array of variable names (`string[]`) to remove.\n\t */\n\tpublic removeVariables(variableNames: string[]): void {\n\t\tthis.execution.removeVariables(variableNames);\n\t}\n\n\t/**\n\t * Removes the local variables and creates a new HistoricVariableUpdate for each of them.\n\t * @param variableNames An array of local variable names (`string[]`) to remove.\n\t */\n\tpublic removeVariablesLocal(variableNames: string[]): void {\n\t\tthis.execution.removeVariablesLocal(variableNames);\n\t}\n\n\t/**\n\t * Sets a transient variable using the default scoping mechanism (up the hierarchy). Transient variables have no history and are cleared at wait states.\n\t * @param variableName The name of the transient variable.\n\t * @param variableValue The value of the transient variable (`any`).\n\t */\n\tpublic setTransientVariable(variableName: string, variableValue: any): void {\n\t\tthis.execution.setTransientVariable(variableName, Values.stringifyValue(variableValue));\n\t}\n\n\t/**\n\t * Sets a local transient variable. Transient variables have no history and are cleared at wait states.\n\t * @param variableName The name of the local transient variable.\n\t * @param variableValue The value of the local transient variable (`any`).\n\t */\n\tpublic setTransientVariableLocal(variableName: string, variableValue: any): void {\n\t\tthis.execution.setTransientVariableLocal(variableName, Values.stringifyValue(variableValue));\n\t}\n\n\t/**\n\t * Sets multiple transient variables using the default scoping mechanism (up the hierarchy).\n\t * @param transientVariables A map of keys (`string`) and values (`any`) for the transient variables to be set.\n\t */\n\tpublic setTransientVariables(transientVariables: Map<string, any>): void {\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.execution.setTransientVariables(transientVariables);\n\t}\n\n\t/**\n\t * Retrieves the value of a transient variable, searching up the parent scopes.\n\t * @param variableName The name of the transient variable to retrieve.\n\t * @returns The value of the transient variable (`any`), or `null` if not found.\n\t */\n\tpublic getTransientVariable(variableName: string): any {\n\t\treturn Values.parseValue(this.execution.getTransientVariable(variableName));\n\t}\n\n\t/**\n\t * Retrieves all transient variables in the current scope hierarchy.\n\t * @returns A Map of transient variable names (`string`) to values (`any`).\n\t */\n\tpublic getTransientVariables(): Map<string, any> {\n\t\tconst transientVariables = this.execution.getTransientVariables();\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn transientVariables;\n\t}\n\n\t/**\n\t * Sets multiple local transient variables.\n\t * @param transientVariables A map of keys (`string`) and values (`any`) for the local transient variables to be set.\n\t */\n\tpublic setTransientVariablesLocal(transientVariables: Map<string, any>): void {\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.execution.setTransientVariablesLocal(transientVariables);\n\t}\n\n\t/**\n\t * Retrieves the value of a local transient variable.\n\t * @param variableName The name of the local transient variable to retrieve.\n\t * @returns The value of the local transient variable (`any`), or `null` if not found.\n\t */\n\tpublic getTransientVariableLocal(variableName: string): any {\n\t\treturn Values.parseValue(this.execution.getTransientVariableLocal(variableName));\n\t}\n\n\t/**\n\t * Retrieves all local transient variables.\n\t * @returns A Map of local transient variable names (`string`) to values (`any`).\n\t */\n\tpublic getTransientVariablesLocal(): Map<string, any> {\n\t\tconst transientVariablesLocal = this.execution.getTransientVariablesLocal();\n\t\tfor (const [key, value] of transientVariablesLocal) {\n\t\t\ttransientVariablesLocal.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn transientVariablesLocal;\n\t}\n\n\t/**\n\t * Removes a specific local transient variable.\n\t * @param variableName The name of the local transient variable to remove.\n\t */\n\tpublic removeTransientVariableLocal(variableName: string): void {\n\t\tthis.execution.removeTransientVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes a specific transient variable, searching up the scope hierarchy.\n\t * @param variableName The name of the transient variable to remove.\n\t */\n\tpublic removeTransientVariable(variableName: string): void {\n\t\tthis.execution.removeTransientVariable(variableName);\n\t}\n\n\t/**\n\t * Remove all transient variables of this scope and its parent scopes.\n\t */\n\tpublic removeTransientVariables(): void {\n\t\tthis.execution.removeTransientVariables();\n\t}\n\n\t/**\n\t * Removes all local transient variables.\n\t */\n\tpublic removeTransientVariablesLocal(): void {\n\t\tthis.execution.removeTransientVariablesLocal();\n\t}\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Process;\n}\n"],
  "mappings": "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",
  "names": []
}
