@unmeshed/sdk 1.0.13 → 1.0.15

package/dist/index.mjs

@@ -0,0 +1,797 @@
+// src/apis/unmeshedApiClient.ts
+import axios from "axios";
+
+// src/utils/unmeshedCommonUtils.ts
+import { createHash } from "crypto";
+var UnmeshedCommonUtils = class {
+  static createSecureHash(input) {
+    try {
+      const hash = createHash("sha256");
+      hash.update(input, "utf8");
+      return hash.digest("hex");
+    } catch (e) {
+      throw new Error("Error creating hash");
+    }
+  }
+};
+
+// src/apis/unmeshedApiClient.ts
+var UnmeshedApiClient = class {
+  axiosInstance = null;
+  clientId = void 0;
+  _config;
+  constructor(unmeshedClientConfig) {
+    console.log("Initializing Unmeshed ApiClient");
+    this._config = createUnmeshedClientConfig(unmeshedClientConfig);
+    console.log(this._config);
+    this.clientId = this._config.clientId;
+    if (!this._config.baseUrl) {
+      throw new Error("baseUrl is required");
+    }
+    const baseURL = this._config.port ? `${this._config.baseUrl}:${this._config.port}` : this._config.baseUrl;
+    this.axiosInstance = axios.create({
+      baseURL,
+      timeout: this._config.timeout,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer client.sdk.${this._config.clientId}.${UnmeshedCommonUtils.createSecureHash(
+          this._config.authToken
+        )}`
+      }
+    });
+  }
+  async handleRequest({
+    method,
+    endpoint,
+    params,
+    data,
+    config
+  }) {
+    if (!this.axiosInstance) {
+      throw new Error("ApiClient must be initialized before making requests");
+    }
+    try {
+      const response = await this.axiosInstance.request({
+        method,
+        url: endpoint,
+        params,
+        data,
+        ...config
+      });
+      return {
+        data: response.data,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        console.error("Request failed:", error.message);
+        throw this.handleError(error);
+      }
+      console.error("Unexpected error:", error.message);
+      throw error;
+    }
+  }
+  handleError(error) {
+    console.error("Error details:", {
+      message: error.message,
+      status: error.response?.status,
+      data: error.response?.data
+    });
+    let response = error?.response?.data;
+    if (response?.errorMessage) {
+      return new Error(`${response.errorMessage} [Status code: ${error.response?.status || ""}]`);
+    }
+    return new Error(error.message, { cause: error.response?.data || {} });
+  }
+  async get(endpoint, params, config) {
+    return this.handleRequest({
+      method: "get",
+      endpoint,
+      params,
+      config
+    });
+  }
+  async post(endpoint, clientRequestConfig) {
+    return this.handleRequest({
+      method: "post",
+      endpoint,
+      ...clientRequestConfig
+    });
+  }
+  async put(endpoint, clientRequestConfig) {
+    return this.handleRequest({
+      method: "put",
+      endpoint,
+      ...clientRequestConfig
+    });
+  }
+  async delete(endpoint, clientRequestConfig) {
+    return this.handleRequest({
+      method: "delete",
+      endpoint,
+      ...clientRequestConfig
+    });
+  }
+  getClientId() {
+    return this.clientId;
+  }
+  get config() {
+    return this._config;
+  }
+};
+function createUnmeshedClientConfig(config) {
+  return {
+    baseUrl: config.baseUrl,
+    clientId: config.clientId,
+    authToken: config.authToken,
+    port: config.port ?? 443,
+    timeout: config.timeout ?? 5e3,
+    pollInterval: config.pollInterval ?? 100,
+    apiWorkerTimeout: config.apiWorkerTimeout ?? 1e4,
+    pollTimeout: config.pollTimeout ?? 1e4,
+    responsePollInterval: config.responsePollInterval ?? 100,
+    responsePollTimeout: config.responsePollTimeout ?? 1e4,
+    responseBatchSize: config.responseBatchSize ?? 50
+  };
+}
+
+// src/types/index.ts
+var ApiCallType = /* @__PURE__ */ ((ApiCallType2) => {
+  ApiCallType2["SYNC"] = "SYNC";
+  ApiCallType2["ASYNC"] = "ASYNC";
+  ApiCallType2["STREAM"] = "STREAM";
+  return ApiCallType2;
+})(ApiCallType || {});
+var WebhookSource = /* @__PURE__ */ ((WebhookSource2) => {
+  WebhookSource2["MS_TEAMS"] = "MS_TEAMS";
+  WebhookSource2["NOT_DEFINED"] = "NOT_DEFINED";
+  return WebhookSource2;
+})(WebhookSource || {});
+var SQAuthUserType = /* @__PURE__ */ ((SQAuthUserType2) => {
+  SQAuthUserType2["USER"] = "USER";
+  SQAuthUserType2["API"] = "API";
+  SQAuthUserType2["INTERNAL"] = "INTERNAL";
+  return SQAuthUserType2;
+})(SQAuthUserType || {});
+var StepType = /* @__PURE__ */ ((StepType2) => {
+  StepType2["WORKER"] = "WORKER";
+  StepType2["HTTP"] = "HTTP";
+  StepType2["WAIT"] = "WAIT";
+  StepType2["FAIL"] = "FAIL";
+  StepType2["PYTHON"] = "PYTHON";
+  StepType2["JAVASCRIPT"] = "JAVASCRIPT";
+  StepType2["JQ"] = "JQ";
+  StepType2["MANAGED"] = "MANAGED";
+  StepType2["BUILTIN"] = "BUILTIN";
+  StepType2["NOOP"] = "NOOP";
+  StepType2["PERSISTED_STATE"] = "PERSISTED_STATE";
+  StepType2["DEPENDSON"] = "DEPENDSON";
+  StepType2["INTEGRATION"] = "INTEGRATION";
+  StepType2["EXIT"] = "EXIT";
+  StepType2["SUB_PROCESS"] = "SUB_PROCESS";
+  StepType2["LIST"] = "LIST";
+  StepType2["PARALLEL"] = "PARALLEL";
+  StepType2["FOREACH"] = "FOREACH";
+  StepType2["SWITCH"] = "SWITCH";
+  return StepType2;
+})(StepType || {});
+var StepStatus = /* @__PURE__ */ ((StepStatus2) => {
+  StepStatus2["PENDING"] = "PENDING";
+  StepStatus2["SCHEDULED"] = "SCHEDULED";
+  StepStatus2["RUNNING"] = "RUNNING";
+  StepStatus2["PAUSED"] = "PAUSED";
+  StepStatus2["COMPLETED"] = "COMPLETED";
+  StepStatus2["FAILED"] = "FAILED";
+  StepStatus2["TIMED_OUT"] = "TIMED_OUT";
+  StepStatus2["SKIPPED"] = "SKIPPED";
+  StepStatus2["CANCELLED"] = "CANCELLED";
+  return StepStatus2;
+})(StepStatus || {});
+var ProcessStatus = /* @__PURE__ */ ((ProcessStatus2) => {
+  ProcessStatus2["RUNNING"] = "RUNNING";
+  ProcessStatus2["COMPLETED"] = "COMPLETED";
+  ProcessStatus2["FAILED"] = "FAILED";
+  ProcessStatus2["TIMED_OUT"] = "TIMED_OUT";
+  ProcessStatus2["CANCELLED"] = "CANCELLED";
+  ProcessStatus2["TERMINATED"] = "TERMINATED";
+  ProcessStatus2["REVIEWED"] = "REVIEWED";
+  return ProcessStatus2;
+})(ProcessStatus || {});
+var ProcessTriggerType = /* @__PURE__ */ ((ProcessTriggerType2) => {
+  ProcessTriggerType2["MANUAL"] = "MANUAL";
+  ProcessTriggerType2["SCHEDULED"] = "SCHEDULED";
+  ProcessTriggerType2["API_MAPPING"] = "API_MAPPING";
+  ProcessTriggerType2["WEBHOOK"] = "WEBHOOK";
+  ProcessTriggerType2["API"] = "API";
+  ProcessTriggerType2["SUB_PROCESS"] = "SUB_PROCESS";
+  return ProcessTriggerType2;
+})(ProcessTriggerType || {});
+var ProcessType = /* @__PURE__ */ ((ProcessType2) => {
+  ProcessType2["STANDARD"] = "STANDARD";
+  ProcessType2["DYNAMIC"] = "DYNAMIC";
+  ProcessType2["API_ORCHESTRATION"] = "API_ORCHESTRATION";
+  ProcessType2["INTERNAL"] = "INTERNAL";
+  return ProcessType2;
+})(ProcessType || {});
+
+// src/apis/queuedWorker.ts
+var QueuedWorker = class {
+  queue;
+  pollIntervalMs;
+  batchSize;
+  workerFn;
+  timeoutMs;
+  constructor(capacity, pollIntervalMs, batchSize, workerFn, timeoutMs) {
+    this.queue = new BlockingQueue(capacity);
+    this.pollIntervalMs = pollIntervalMs;
+    this.batchSize = batchSize;
+    this.workerFn = workerFn;
+    this.timeoutMs = timeoutMs;
+    console.log(`Configured queued worker with ${pollIntervalMs} ms interval and batch size of ${batchSize} and a timeout of ${timeoutMs} ms`);
+    this.start();
+  }
+  async start() {
+    let errorCount = 0;
+    while (true) {
+      try {
+        const batch = await this.queue.takeBatch(this.batchSize);
+        if (batch.length > 0) {
+          console.log(`Batch work ${batch.length} received`);
+          await this.runWithTimeout(this.workerFn(batch), this.timeoutMs);
+        }
+      } catch (error) {
+        errorCount++;
+        console.error(`Error processing batch - error count : ${errorCount} - `, error);
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+      await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+    }
+  }
+  async runWithTimeout(task, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("Task timed out")), timeoutMs);
+      task.then(() => {
+        clearTimeout(timeout);
+        resolve();
+      }).catch((error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+  }
+  async put(item) {
+    await this.queue.put(item);
+  }
+};
+var BlockingQueue = class {
+  queue = [];
+  capacity;
+  constructor(capacity) {
+    if (capacity <= 0) {
+      throw new Error("Capacity must be greater than 0");
+    }
+    this.capacity = capacity;
+  }
+  async put(item) {
+    while (this.queue.length >= this.capacity) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    this.queue.push(item);
+  }
+  async takeBatch(batchSize) {
+    while (this.queue.length === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    return this.queue.splice(0, batchSize);
+  }
+  size() {
+    return this.queue.length;
+  }
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  peek() {
+    return this.queue[0];
+  }
+};
+
+// src/apis/pollerClientImpl.ts
+async function registerPolling(apiClient, data) {
+  const attempt = async () => {
+    try {
+      const response = await apiClient.put("/api/clients/register", {
+        data
+      });
+      console.log("Successfully renewed registration for workers", data);
+      return response.data;
+    } catch {
+      console.error(
+        "An error occurred during polling registration. Retrying in 3 seconds..."
+      );
+      await new Promise((resolve) => setTimeout(resolve, 3e3));
+      return attempt();
+    }
+  };
+  return attempt();
+}
+async function pollWorker(apiClient, data) {
+  try {
+    const response = await apiClient.post("/api/clients/poll", { data });
+    if (response.data && response.data.length > 0) {
+      console.log(`Received ${response.data.length} work requests`);
+    }
+    return response.data;
+  } catch (error) {
+    console.error("Error occurred during worker polling", error);
+  }
+}
+async function postWorkerResponse(apiClient, workResponses) {
+  try {
+    if (workResponses.length > 0) {
+      const grouped = workResponses.reduce((acc, response2) => {
+        if (!acc[response2.status]) {
+          acc[response2.status] = [];
+        }
+        acc[response2.status].push(response2.stepId);
+        return acc;
+      }, {});
+      const resultString = Object.entries(grouped).map(([status, stepIds]) => `${status}: [${stepIds.join(", ")}]`).join(", ");
+      console.log(`Posting response of size: ${workResponses.length} including ids: ${resultString}`);
+      const response = await apiClient.post("/api/clients/bulkResults", {
+        data: workResponses
+      });
+      return response.data;
+    }
+    return {};
+  } catch (error) {
+    console.log("Error:", error);
+  }
+}
+async function runPollWithTimeout(task, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("Task timed out")), timeoutMs);
+    task.then((workRequests) => {
+      clearTimeout(timeout);
+      resolve(workRequests);
+    }).catch((error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+  });
+}
+var continuePolling = {
+  value: true
+};
+async function pollForWorkers(apiClient, workers) {
+  const queuedWorker = new QueuedWorker(
+    1e5,
+    apiClient.config.responsePollInterval,
+    apiClient.config.responseBatchSize,
+    async (batchWork) => {
+      await postWorkerResponse(apiClient, batchWork);
+    },
+    apiClient.config.responsePollTimeout
+  );
+  const registerPollingData = workers.map((worker) => {
+    return {
+      orgId: 0,
+      namespace: worker.namespace,
+      stepType: "WORKER",
+      name: worker.name
+    };
+  });
+  await registerPolling(apiClient, registerPollingData);
+  const pollWorkerData = workers.map((worker) => {
+    return {
+      stepQueueNameData: {
+        orgId: 0,
+        namespace: worker.namespace,
+        stepType: "WORKER",
+        name: worker.name
+      },
+      size: worker.maxInProgress
+    };
+  });
+  let errorCount = 0;
+  while (continuePolling.value) {
+    try {
+      const workRequests = await runPollWithTimeout(pollWorker(apiClient, pollWorkerData), apiClient.config.pollTimeout);
+      for (const polledWorker of workRequests) {
+        const associatedWorker = workers.find(
+          (worker) => worker.name === polledWorker.stepName && worker.namespace === polledWorker.stepNamespace
+        );
+        let workerResponse = {
+          processId: polledWorker.processId,
+          stepId: polledWorker.stepId,
+          stepExecutionId: polledWorker.stepExecutionId,
+          runCount: polledWorker.runCount,
+          output: {},
+          status: "RUNNING" /* RUNNING */,
+          rescheduleAfterSeconds: null,
+          startedAt: (/* @__PURE__ */ new Date()).getTime()
+        };
+        if (!associatedWorker) {
+          workerResponse = {
+            ...workerResponse,
+            output: {
+              error: `No worker found for ${polledWorker.stepName} ${polledWorker.stepNamespace}`
+            },
+            status: "TIMED_OUT" /* TIMED_OUT */
+          };
+          await queuedWorker.put(workerResponse);
+          continue;
+        }
+        const TIMEOUT = apiClient.config.apiWorkerTimeout;
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => reject(new Error("Timed out")), TIMEOUT);
+        });
+        try {
+          console.log(`Starting work ${polledWorker.processId} : ${polledWorker.stepId} : ${polledWorker.stepName} : ${polledWorker.stepRef}`);
+          const result = await Promise.race([
+            associatedWorker.worker(polledWorker.inputParam),
+            timeoutPromise
+          ]);
+          workerResponse = {
+            ...workerResponse,
+            output: {
+              ...result,
+              __workCompletedAt: (/* @__PURE__ */ new Date()).getTime()
+            },
+            status: "COMPLETED" /* COMPLETED */
+          };
+        } catch (error) {
+          const err = error;
+          if (err.message && err.message === "Timed out") {
+            workerResponse = {
+              ...workerResponse,
+              output: {
+                error: `${err.message} based on work timeout settings in worker - ${apiClient.config.apiWorkerTimeout} ms`
+              },
+              status: "TIMED_OUT" /* TIMED_OUT */
+            };
+          } else {
+            workerResponse = {
+              ...workerResponse,
+              output: {
+                error: safeStringifyError(err)
+              },
+              status: "FAILED" /* FAILED */
+            };
+            console.error("Error:", err.message);
+          }
+        }
+        await queuedWorker.put(workerResponse);
+      }
+      await new Promise((resolve) => setTimeout(resolve, apiClient.config.pollInterval));
+    } catch (error) {
+      errorCount++;
+      console.error(`Error processing batch - error count : ${errorCount} - `, error);
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+  }
+}
+function safeStringifyError(error) {
+  try {
+    if (error instanceof Error) {
+      const plainError = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+        ...error
+        // Include enumerable custom properties if they exist
+      };
+      return JSON.stringify(plainError);
+    }
+    return JSON.stringify(error);
+  } catch (stringifyError) {
+    return `Error stringification failed: ${stringifyError.message}`;
+  }
+}
+async function startPollingWorkers(apiClient, workers, intervalMs = 5e3) {
+  async function pollCycle() {
+    try {
+      await pollForWorkers(apiClient, workers);
+    } catch (error) {
+      console.error("Error during worker polling:", error);
+    }
+    setTimeout(pollCycle, intervalMs);
+  }
+  await pollCycle();
+}
+
+// src/apis/processClientImpl.ts
+import { isAxiosError } from "axios";
+var RUN_PROCESS_REQUEST_URL = "api/process/";
+var runProcessSync = async (apiClient, ProcessRequestData2) => {
+  try {
+    const response = await apiClient.post(RUN_PROCESS_REQUEST_URL + "runSync", {
+      data: ProcessRequestData2,
+      params: {
+        clientId: apiClient.getClientId()
+      }
+    });
+    console.log("Response:", response);
+    return response.data;
+  } catch (error) {
+    console.error("Some error occurred running process request : ", error);
+    throw error;
+  }
+};
+var runProcessAsync = async (apiClient, ProcessRequestData2) => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "runAsync",
+      {
+        data: ProcessRequestData2,
+        params: {
+          clientId: apiClient.getClientId()
+        }
+      }
+    );
+    console.log("Response:", response);
+    return response.data;
+  } catch (error) {
+    console.error("Some error occurred running process request : ", error);
+    throw error;
+  }
+};
+var getProcessData = async (apiClient, processId) => {
+  if (processId == null) {
+    throw new Error("Process ID cannot be null");
+  }
+  try {
+    const response = await apiClient.get(
+      RUN_PROCESS_REQUEST_URL + "context/" + processId
+    );
+    return response.data;
+  } catch (error) {
+    console.error("Error occurred while fetching process record: ", error);
+    throw error;
+  }
+};
+var getStepData = async (apiClient, stepId) => {
+  if (stepId === null || stepId === void 0) {
+    throw new Error("Step ID cannot be null or undefined");
+  }
+  try {
+    const response = await apiClient.get(
+      RUN_PROCESS_REQUEST_URL + "stepContext/" + stepId
+    );
+    return response.data;
+  } catch (error) {
+    console.log("Error occurred while getStepData: ", error);
+    throw error;
+  }
+};
+var bulkTerminate = async (apiClient, processIds, reason) => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "bulkTerminate",
+      {
+        params: { reason },
+        data: processIds
+      }
+    );
+    return response.data;
+  } catch (error) {
+    const err = error;
+    throw new Error(
+      `Error occurred while terminating processes: ${err.message || error}`
+    );
+  }
+};
+var bulkResume = async (apiClient, processIds) => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "bulkResume",
+      {
+        data: processIds
+      }
+    );
+    return response.data;
+  } catch (error) {
+    const err = error;
+    throw new Error(
+      `Error occurred while resuming processes: ${err.message || error}`
+    );
+  }
+};
+var bulkReviewed = async (apiClient, processIds, reason) => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "bulkReviewed",
+      {
+        data: processIds,
+        params: { reason }
+      }
+    );
+    return response.data;
+  } catch (error) {
+    const err = error;
+    throw new Error(
+      `Error occurred while marking processes as reviewed: ${err.message || error}`
+    );
+  }
+};
+var rerun = async (apiClient, processId, clientId, version) => {
+  const params = {
+    clientId,
+    processId
+  };
+  if (version !== void 0) {
+    params["version"] = version;
+  }
+  try {
+    const response = await apiClient.post(RUN_PROCESS_REQUEST_URL + "rerun", {
+      params
+    });
+    return response.data;
+  } catch (error) {
+    if (isAxiosError(error)) {
+      throw new Error(
+        `HTTP request error during rerun process: ${error.response?.status} - ${error.response?.data}`
+      );
+    } else {
+      const err = error;
+      throw new Error(
+        `Unexpected error during rerun process: ${err.message || err}`
+      );
+    }
+  }
+};
+var searchProcessExecutions = async (apiClient, params) => {
+  const queryParams = new URLSearchParams();
+  if (params.startTimeEpoch !== void 0 && params.startTimeEpoch !== 0)
+    queryParams.set("startTimeEpoch", params.startTimeEpoch.toString());
+  if (params.endTimeEpoch !== void 0 && params.endTimeEpoch !== 0)
+    queryParams.set("endTimeEpoch", (params.endTimeEpoch || 0).toString());
+  if (params.namespace) queryParams.set("namespace", params.namespace);
+  if (params.names && params.names.length)
+    queryParams.set("names", params.names.join(","));
+  if (params.processIds && params.processIds.length)
+    queryParams.set("processIds", params.processIds.join(","));
+  if (params.correlationIds && params.correlationIds.length)
+    queryParams.set("correlationIds", params.correlationIds.join(","));
+  if (params.requestIds && params.requestIds.length)
+    queryParams.set("requestIds", params.requestIds.join(","));
+  if (params.statuses && params.statuses.length)
+    queryParams.set("statuses", params.statuses.join(","));
+  if (params.triggerTypes && params.triggerTypes.length)
+    queryParams.set("triggerTypes", params.triggerTypes.join(","));
+  const updatedParams = Object.fromEntries(new URLSearchParams(queryParams));
+  try {
+    const response = await apiClient.get(
+      RUN_PROCESS_REQUEST_URL + "api/stats/process/search",
+      updatedParams
+    );
+    console.log("Response:", response);
+    return response.data;
+  } catch (error) {
+    console.error("Error occurred while searching process executions: ", error);
+    throw error;
+  }
+};
+var invokeApiMappingGet = async (apiClient, endpoint, id, correlationId, apiCallType) => {
+  try {
+    const response = await apiClient.get(
+      RUN_PROCESS_REQUEST_URL + "api/call/" + endpoint,
+      {
+        id,
+        correlationId,
+        apiCallType
+      }
+    );
+    console.log("Response:", response);
+    return response.data;
+  } catch (error) {
+    console.error("Error occurred while invoking API Mapping GET: ", error);
+    throw error;
+  }
+};
+var invokeApiMappingPost = async (apiClient, endpoint, input, id, correlationId, apiCallType = "ASYNC" /* ASYNC */) => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "api/call/" + endpoint,
+      {
+        data: input,
+        params: {
+          id,
+          correlationId,
+          apiCallType
+        }
+      }
+    );
+    return response.data;
+  } catch (error) {
+    console.error("Error occurred while invoking API Mapping POST: ", error);
+    throw error;
+  }
+};
+
+// src/apis/registrationClientImpl.ts
+var renewRegistration = async (apiClient, params) => {
+  try {
+    const response = await apiClient.put("/api/clients/register", {
+      params: { ...params }
+    });
+    console.debug("Response from server:", response);
+    return response.data;
+  } catch (error) {
+    console.error("Error occurred during registration renewal:", error);
+    throw error;
+  }
+};
+
+// src/index.ts
+var UnmeshedClient = class {
+  client;
+  constructor(config) {
+    this.client = new UnmeshedApiClient(config);
+  }
+  startPolling(workers) {
+    startPollingWorkers(this.client, workers);
+  }
+  // Other methods for interacting with Unmeshed API
+  runProcessSync(ProcessRequestData2) {
+    return runProcessSync(this.client, ProcessRequestData2);
+  }
+  runProcessAsync(ProcessRequestData2) {
+    return runProcessAsync(this.client, ProcessRequestData2);
+  }
+  getProcessData(processId) {
+    return getProcessData(this.client, processId);
+  }
+  getStepData(stepId) {
+    return getStepData(this.client, stepId);
+  }
+  bulkTerminate(processIds, reason) {
+    return bulkTerminate(this.client, processIds, reason);
+  }
+  bulkResume(processIds) {
+    return bulkResume(this.client, processIds);
+  }
+  bulkReviewed(processIds, reason) {
+    return bulkReviewed(this.client, processIds, reason);
+  }
+  reRun(processId, clientId, version) {
+    return rerun(this.client, processId, clientId, version);
+  }
+  searchProcessExecution(params) {
+    return searchProcessExecutions(this.client, params);
+  }
+  invokeApiMappingGet(apiClient, endpoint, id, correlationId, apiCallType) {
+    return invokeApiMappingGet(
+      apiClient,
+      endpoint,
+      id,
+      correlationId,
+      apiCallType
+    );
+  }
+  invokeApiMappingPost(endpoint, input, id, correlationId, apiCallType) {
+    return invokeApiMappingPost(
+      this.client,
+      endpoint,
+      input,
+      id,
+      correlationId,
+      apiCallType
+    );
+  }
+  reNewRegistration(params) {
+    return renewRegistration(this.client, params);
+  }
+};
+export {
+  ApiCallType,
+  ProcessStatus,
+  ProcessTriggerType,
+  ProcessType,
+  SQAuthUserType,
+  StepStatus,
+  StepType,
+  UnmeshedClient,
+  WebhookSource
+};
+//# sourceMappingURL=index.mjs.map