@camunda8/orchestration-cluster-api 10.0.0-alpha.15 → 10.0.0-alpha.16

package/dist/{chunk-BDHUY2UM.js → chunk-RTRUW7ZX.js}

@@ -331,12 +331,12 @@ var JobWorker = class {
   constructor(client2, cfg) {
     this._client = client2;
     this._cfg = {
-      pollIntervalMs: 1,
-      autoStart: true,
-      validateSchemas: false,
-      maxParallelJobs: 10,
-      jobTimeoutMs: 6e4,
-      ...cfg
+      ...cfg,
+      pollIntervalMs: cfg.pollIntervalMs ?? 1,
+      autoStart: cfg.autoStart ?? true,
+      validateSchemas: cfg.validateSchemas ?? false,
+      maxParallelJobs: cfg.maxParallelJobs ?? 10,
+      jobTimeoutMs: cfg.jobTimeoutMs ?? 6e4
     };
     this._maxParallelJobs = this._cfg.maxParallelJobs;
     this._jobTimeoutMs = this._cfg.jobTimeoutMs;
@@ -3680,6 +3680,28 @@ var getProcessDefinitionStatistics = (options) => {
     }
   });
 };
+var searchProcessDefinitionVariableNames = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/process-definitions/{processDefinitionKey}/variable-names/search",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var getProcessDefinitionXml = (options) => {
   return (options.client ?? client).get({
     requestValidator: void 0,
@@ -3852,6 +3874,28 @@ var modifyProcessInstancesBatchOperation = (options) => {
     }
   });
 };
+var resumeProcessInstancesBatchOperation = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/process-instances/resumption",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var searchProcessInstances = (options) => {
   return (options?.client ?? client).post({
     requestValidator: void 0,
@@ -3874,6 +3918,28 @@ var searchProcessInstances = (options) => {
     }
   });
 };
+var suspendProcessInstancesBatchOperation = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/process-instances/suspension",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var getProcessInstance = (options) => {
   return (options.client ?? client).get({
     requestValidator: void 0,
@@ -3892,6 +3958,28 @@ var getProcessInstance = (options) => {
     ...options
   });
 };
+var assignProcessInstanceBusinessId = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/process-instances/{processInstanceKey}/business-id-assignment",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var getProcessInstanceCallHierarchy = (options) => {
   return (options.client ?? client).get({
     requestValidator: void 0,
@@ -4038,6 +4126,28 @@ var modifyProcessInstance = (options) => {
     }
   });
 };
+var resumeProcessInstance = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/process-instances/{processInstanceKey}/resumption",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var getProcessInstanceSequenceFlows = (options) => {
   return (options.client ?? client).get({
     requestValidator: void 0,
@@ -4092,6 +4202,28 @@ var getProcessInstanceWaitStateStatistics = (options) => {
     ...options
   });
 };
+var suspendProcessInstance = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/process-instances/{processInstanceKey}/suspension",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var searchResources = (options) => {
   return (options?.client ?? client).post({
     requestValidator: void 0,
@@ -4524,6 +4656,28 @@ var assignRoleToUser = (options) => {
     ...options
   });
 };
+var resolveSecrets = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/secrets/resolve",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var createAdminUser = (options) => {
   return (options.client ?? client).post({
     requestValidator: void 0,
@@ -5012,6 +5166,46 @@ var getTopology = (options) => {
     ...options
   });
 };
+var changeClusterMode = (options) => {
+  return (options.client ?? client).patch({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/mode",
+    ...options
+  });
+};
+var restore = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      },
+      {
+        scheme: "basic",
+        type: "http"
+      }
+    ],
+    url: "/restore",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var createUser = (options) => {
   return (options.client ?? client).post({
     requestValidator: void 0,
@@ -5751,7 +5945,8 @@ var SCHEMA = {
   CAMUNDA_REST_ADDRESS: {
     type: "string",
     default: "http://localhost:8080/v2",
-    doc: "Base REST endpoint address."
+    aliases: ["ZEEBE_REST_ADDRESS"],
+    doc: "Base REST endpoint address. Legacy alias: ZEEBE_REST_ADDRESS (used only when CAMUNDA_REST_ADDRESS is unset)."
   },
   CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS: {
     desc: "Maximum total HTTP attempts (including the initial attempt) for transient failures (429,503, network).",
@@ -5982,6 +6177,12 @@ function isSecret(key) {
 function requiredWhen(key) {
   return SCHEMA[key].requiredWhen;
 }
+function aliases(key) {
+  return SCHEMA[key].aliases ?? [];
+}
+function defaultValue(key) {
+  return SCHEMA[key].default;
+}
 function schemaEntry(key) {
   return SCHEMA[key];
 }
@@ -6194,30 +6395,56 @@ function hydrateConfig(options = {}) {
   if (envInput.CAMUNDA_SUPPORT_LOG_ENABLED === void 0 && envInput.CAMUNDA_SUPPORT_LOGGER !== void 0) {
     envInput.CAMUNDA_SUPPORT_LOG_ENABLED = envInput.CAMUNDA_SUPPORT_LOGGER;
   }
-  if (envInput.CAMUNDA_REST_ADDRESS === void 0 && baseEnv.ZEEBE_REST_ADDRESS !== void 0 && baseEnv.ZEEBE_REST_ADDRESS.trim() !== "") {
-    envInput.CAMUNDA_REST_ADDRESS = baseEnv.ZEEBE_REST_ADDRESS.trim();
-  }
-  if ((envInput.CAMUNDA_AUTH_STRATEGY === void 0 || envInput.CAMUNDA_AUTH_STRATEGY.trim() === "") && envInput.CAMUNDA_OAUTH_URL !== void 0 && envInput.CAMUNDA_OAUTH_URL.trim() !== "" && envInput.CAMUNDA_CLIENT_ID !== void 0 && envInput.CAMUNDA_CLIENT_ID.trim() !== "" && envInput.CAMUNDA_CLIENT_SECRET !== void 0 && envInput.CAMUNDA_CLIENT_SECRET.trim() !== "") {
-    envInput.CAMUNDA_AUTH_STRATEGY = "OAUTH";
+  for (const k of allKeys()) {
+    if (envInput[k] !== void 0) continue;
+    for (const alias of aliases(k)) {
+      const aliasVal = baseEnv[alias];
+      if (aliasVal !== void 0 && aliasVal.trim() !== "") {
+        envInput[k] = aliasVal.trim();
+        break;
+      }
+    }
   }
   let envTyped = {};
   envTyped = createEnv(typedEnvSchema, { env: envInput });
   for (const k of allKeys()) {
     const entry = schemaEntry(k);
     const rawProvided = envInput[k];
+    const providedIsEmpty = rawProvided !== void 0 && rawProvided.trim() === "";
     const val = envTyped[k];
-    if (val !== void 0 && val !== null) {
+    const valIsEmptyString = typeof val === "string" && val.trim() === "";
+    if (val !== void 0 && val !== null && !valIsEmptyString) {
       rawMap[k] = typeof val === "string" ? val : String(val);
-    } else if (rawProvided !== void 0) {
+    } else if (rawProvided !== void 0 && !providedIsEmpty && val === void 0) {
     } else if (entry.default !== void 0) {
       rawMap[k] = String(entry.default);
     }
   }
-  if (!userSetStrategy && rawMap.CAMUNDA_AUTH_STRATEGY === "NONE" && rawMap.CAMUNDA_OAUTH_URL && rawMap.CAMUNDA_OAUTH_URL.trim() !== "" && rawMap.CAMUNDA_CLIENT_ID && rawMap.CAMUNDA_CLIENT_ID.trim() !== "" && rawMap.CAMUNDA_CLIENT_SECRET && rawMap.CAMUNDA_CLIENT_SECRET.trim() !== "") {
+  if (!userSetStrategy && rawMap.CAMUNDA_AUTH_STRATEGY === "NONE" && rawMap.CAMUNDA_OAUTH_URL?.trim() && rawMap.CAMUNDA_CLIENT_ID?.trim() && rawMap.CAMUNDA_CLIENT_SECRET?.trim()) {
     rawMap.CAMUNDA_AUTH_STRATEGY = "OAUTH";
   }
-  const authStrategyRaw = (rawMap.CAMUNDA_AUTH_STRATEGY || "NONE").toString();
-  const authStrategy = authStrategyRaw.trim().toUpperCase();
+  const reqStr = (k) => {
+    const v = rawMap[k];
+    if (v !== void 0 && v.trim() !== "") return v;
+    const d = defaultValue(k);
+    if (d !== void 0) return String(d);
+    if (v !== void 0) return v;
+    throw new Error(`Internal configuration error: no value or schema default for ${k}`);
+  };
+  const reqInt = (k) => {
+    const n = parseInt(reqStr(k), 10);
+    if (Number.isNaN(n)) {
+      throw new Error(`Internal configuration error: ${k} is not a valid integer`);
+    }
+    return n;
+  };
+  const reqBool = (k) => {
+    const typed = envTyped[k];
+    if (typeof typed === "boolean") return typed;
+    return reqStr(k).trim().toLowerCase() === "true";
+  };
+  const authStrategyRaw = reqStr("CAMUNDA_AUTH_STRATEGY");
+  const authStrategy = authStrategyRaw;
   if (!["NONE", "OAUTH", "BASIC"].includes(authStrategy)) {
     errors.push({
       code: "CONFIG_INVALID_ENUM" /* CONFIG_INVALID_ENUM */,
@@ -6265,7 +6492,7 @@ function hydrateConfig(options = {}) {
       message: "CAMUNDA_MTLS_KEY_PASSPHRASE is set but no client key was provided."
     });
   }
-  const validationRaw = rawMap.CAMUNDA_SDK_VALIDATION || "req:none,res:none";
+  const validationRaw = reqStr("CAMUNDA_SDK_VALIDATION");
   const validation = parseValidation(validationRaw, errors);
   if (errors.length) {
     errors.sort((a, b) => (a.key || "").localeCompare(b.key || "") || a.code.localeCompare(b.code));
@@ -6280,7 +6507,7 @@ function hydrateConfig(options = {}) {
     if (isSecret(k) && v) redacted[k] = redactSecret(v);
     else redacted[k] = v;
   }
-  let _restAddress = rawMap.CAMUNDA_REST_ADDRESS;
+  let _restAddress = reqStr("CAMUNDA_REST_ADDRESS");
   if (_restAddress) {
     _restAddress = _restAddress.trim();
     if (!/\/v2\/?$/i.test(_restAddress)) {
@@ -6288,21 +6515,22 @@ function hydrateConfig(options = {}) {
     } else {
     }
   }
-  const profile = (rawMap.CAMUNDA_SDK_BACKPRESSURE_PROFILE || "BALANCED").toString().toUpperCase();
+  const profile = reqStr("CAMUNDA_SDK_BACKPRESSURE_PROFILE");
+  const schemaBpDefaults = {
+    initialMax: reqInt("CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX"),
+    soft: reqInt("CAMUNDA_SDK_BACKPRESSURE_SOFT_FACTOR"),
+    severe: reqInt("CAMUNDA_SDK_BACKPRESSURE_SEVERE_FACTOR"),
+    recoveryInterval: reqInt("CAMUNDA_SDK_BACKPRESSURE_RECOVERY_INTERVAL_MS"),
+    recoveryStep: reqInt("CAMUNDA_SDK_BACKPRESSURE_RECOVERY_STEP"),
+    quietMs: reqInt("CAMUNDA_SDK_BACKPRESSURE_DECAY_QUIET_MS"),
+    floor: reqInt("CAMUNDA_SDK_BACKPRESSURE_FLOOR"),
+    severeThreshold: reqInt("CAMUNDA_SDK_BACKPRESSURE_SEVERE_THRESHOLD"),
+    maxWaiters: reqInt("CAMUNDA_SDK_BACKPRESSURE_MAX_WAITERS"),
+    healthyRecoveryMultiplier: reqInt("CAMUNDA_SDK_BACKPRESSURE_HEALTHY_RECOVERY_MULTIPLIER"),
+    unlimitedAfterHealthyMs: reqInt("CAMUNDA_SDK_BACKPRESSURE_UNLIMITED_AFTER_HEALTHY_MS")
+  };
   const PRESETS = {
-    BALANCED: {
-      initialMax: 16,
-      soft: 70,
-      severe: 50,
-      recoveryInterval: 1e3,
-      recoveryStep: 1,
-      quietMs: 2e3,
-      floor: 1,
-      severeThreshold: 3,
-      maxWaiters: 1e3,
-      healthyRecoveryMultiplier: 150,
-      unlimitedAfterHealthyMs: 3e4
-    },
+    BALANCED: schemaBpDefaults,
     CONSERVATIVE: {
       initialMax: 12,
       soft: 60,
@@ -6329,20 +6557,8 @@ function hydrateConfig(options = {}) {
       healthyRecoveryMultiplier: 200,
       unlimitedAfterHealthyMs: 15e3
     },
-    LEGACY: {
-      // observe-only: we still need plausible defaults if user overrides individual knobs
-      initialMax: 16,
-      soft: 70,
-      severe: 50,
-      recoveryInterval: 1e3,
-      recoveryStep: 1,
-      quietMs: 2e3,
-      floor: 1,
-      severeThreshold: 3,
-      maxWaiters: 1e3,
-      healthyRecoveryMultiplier: 150,
-      unlimitedAfterHealthyMs: 3e4
-    }
+    // observe-only: still needs plausible defaults if the user overrides individual knobs
+    LEGACY: schemaBpDefaults
   };
   const preset = PRESETS[profile] || PRESETS.BALANCED;
   function ensure(k, val) {
@@ -6361,60 +6577,45 @@ function hydrateConfig(options = {}) {
   ensure("CAMUNDA_SDK_BACKPRESSURE_UNLIMITED_AFTER_HEALTHY_MS", preset.unlimitedAfterHealthyMs);
   const config = {
     restAddress: _restAddress,
-    tokenAudience: rawMap.CAMUNDA_TOKEN_AUDIENCE,
-    defaultTenantId: rawMap.CAMUNDA_DEFAULT_TENANT_ID || "<default>",
+    tokenAudience: reqStr("CAMUNDA_TOKEN_AUDIENCE"),
+    defaultTenantId: reqStr("CAMUNDA_DEFAULT_TENANT_ID"),
     httpRetry: {
-      maxAttempts: parseInt(rawMap.CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS || "3", 10),
-      baseDelayMs: parseInt(rawMap.CAMUNDA_SDK_HTTP_RETRY_BASE_DELAY_MS || "100", 10),
-      maxDelayMs: parseInt(rawMap.CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS || "2000", 10)
+      maxAttempts: reqInt("CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS"),
+      baseDelayMs: reqInt("CAMUNDA_SDK_HTTP_RETRY_BASE_DELAY_MS"),
+      maxDelayMs: reqInt("CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS")
     },
     backpressure: {
       enabled: profile !== "LEGACY",
       profile,
       observeOnly: profile === "LEGACY",
-      initialMax: parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX || "16", 10),
-      softFactor: Math.min(
-        1,
-        Math.max(
-          0.01,
-          (parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_SOFT_FACTOR || "70", 10) || 70) / 100
-        )
-      ),
+      initialMax: reqInt("CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX"),
+      softFactor: Math.min(1, Math.max(0.01, reqInt("CAMUNDA_SDK_BACKPRESSURE_SOFT_FACTOR") / 100)),
       severeFactor: Math.min(
         1,
-        Math.max(
-          0.01,
-          (parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_SEVERE_FACTOR || "50", 10) || 50) / 100
-        )
-      ),
-      recoveryIntervalMs: parseInt(
-        rawMap.CAMUNDA_SDK_BACKPRESSURE_RECOVERY_INTERVAL_MS || "1000",
-        10
+        Math.max(0.01, reqInt("CAMUNDA_SDK_BACKPRESSURE_SEVERE_FACTOR") / 100)
       ),
-      recoveryStep: parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_RECOVERY_STEP || "1", 10),
-      decayQuietMs: parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_DECAY_QUIET_MS || "2000", 10),
-      floor: parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_FLOOR || "1", 10),
-      severeThreshold: parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_SEVERE_THRESHOLD || "3", 10),
-      maxWaiters: parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_MAX_WAITERS || "1000", 10),
+      recoveryIntervalMs: reqInt("CAMUNDA_SDK_BACKPRESSURE_RECOVERY_INTERVAL_MS"),
+      recoveryStep: reqInt("CAMUNDA_SDK_BACKPRESSURE_RECOVERY_STEP"),
+      decayQuietMs: reqInt("CAMUNDA_SDK_BACKPRESSURE_DECAY_QUIET_MS"),
+      floor: reqInt("CAMUNDA_SDK_BACKPRESSURE_FLOOR"),
+      severeThreshold: reqInt("CAMUNDA_SDK_BACKPRESSURE_SEVERE_THRESHOLD"),
+      maxWaiters: reqInt("CAMUNDA_SDK_BACKPRESSURE_MAX_WAITERS"),
       healthyRecoveryMultiplier: Math.max(
         1,
-        (parseInt(rawMap.CAMUNDA_SDK_BACKPRESSURE_HEALTHY_RECOVERY_MULTIPLIER || "150", 10) || 150) / 100
+        reqInt("CAMUNDA_SDK_BACKPRESSURE_HEALTHY_RECOVERY_MULTIPLIER") / 100
       ),
-      unlimitedAfterHealthyMs: parseInt(
-        rawMap.CAMUNDA_SDK_BACKPRESSURE_UNLIMITED_AFTER_HEALTHY_MS || "30000",
-        10
-      )
+      unlimitedAfterHealthyMs: reqInt("CAMUNDA_SDK_BACKPRESSURE_UNLIMITED_AFTER_HEALTHY_MS")
     },
     oauth: {
       clientId: rawMap.CAMUNDA_CLIENT_ID?.trim() || void 0,
       clientSecret: rawMap.CAMUNDA_CLIENT_SECRET?.trim() || void 0,
-      oauthUrl: rawMap.CAMUNDA_OAUTH_URL,
-      grantType: rawMap.CAMUNDA_OAUTH_GRANT_TYPE,
+      oauthUrl: reqStr("CAMUNDA_OAUTH_URL"),
+      grantType: reqStr("CAMUNDA_OAUTH_GRANT_TYPE"),
       scope: rawMap.CAMUNDA_OAUTH_SCOPE?.trim() || void 0,
-      timeoutMs: parseInt(rawMap.CAMUNDA_OAUTH_TIMEOUT_MS, 10),
+      timeoutMs: reqInt("CAMUNDA_OAUTH_TIMEOUT_MS"),
       retry: {
-        max: parseInt(rawMap.CAMUNDA_OAUTH_RETRY_MAX, 10),
-        baseDelayMs: parseInt(rawMap.CAMUNDA_OAUTH_RETRY_BASE_DELAY_MS, 10)
+        max: reqInt("CAMUNDA_OAUTH_RETRY_MAX"),
+        baseDelayMs: reqInt("CAMUNDA_OAUTH_RETRY_BASE_DELAY_MS")
       },
       cacheDir: rawMap.CAMUNDA_OAUTH_CACHE_DIR?.trim() || void 0
     },
@@ -6426,9 +6627,9 @@ function hydrateConfig(options = {}) {
       } : void 0
     },
     validation: { req: validation.req, res: validation.res, raw: validation.raw },
-    logLevel: rawMap.CAMUNDA_SDK_LOG_LEVEL || "info",
+    logLevel: reqStr("CAMUNDA_SDK_LOG_LEVEL"),
     eventual: {
-      pollDefaultMs: parseInt(rawMap.CAMUNDA_SDK_EVENTUAL_POLL_DEFAULT_MS || "500", 10)
+      pollDefaultMs: reqInt("CAMUNDA_SDK_EVENTUAL_POLL_DEFAULT_MS")
     },
     mtls: rawMap.CAMUNDA_MTLS_CERT_PATH || rawMap.CAMUNDA_MTLS_KEY_PATH || rawMap.CAMUNDA_MTLS_CA_PATH || rawMap.CAMUNDA_MTLS_CERT || rawMap.CAMUNDA_MTLS_KEY || rawMap.CAMUNDA_MTLS_CA || rawMap.CAMUNDA_MTLS_KEY_PASSPHRASE ? {
       cert: rawMap.CAMUNDA_MTLS_CERT || void 0,
@@ -6440,11 +6641,11 @@ function hydrateConfig(options = {}) {
       caPath: rawMap.CAMUNDA_MTLS_CA_PATH || void 0
     } : void 0,
     telemetry: {
-      log: (rawMap.CAMUNDA_SDK_TELEMETRY_LOG || "false").toString().toLowerCase() === "true",
-      correlation: (rawMap.CAMUNDA_SDK_TELEMETRY_CORRELATION || "false").toString().toLowerCase() === "true"
+      log: reqBool("CAMUNDA_SDK_TELEMETRY_LOG"),
+      correlation: reqBool("CAMUNDA_SDK_TELEMETRY_CORRELATION")
     },
     supportLog: {
-      enabled: (rawMap.CAMUNDA_SUPPORT_LOG_ENABLED || "false").toString().toLowerCase() === "true",
+      enabled: reqBool("CAMUNDA_SUPPORT_LOG_ENABLED"),
       filePath: rawMap.CAMUNDA_SUPPORT_LOG_FILE_PATH || (typeof process !== "undefined" && typeof process.cwd === "function" ? path.join(process.cwd(), "camunda-support.log") : "camunda-support.log")
     },
     workerDefaults: rawMap.CAMUNDA_WORKER_TIMEOUT || rawMap.CAMUNDA_WORKER_MAX_CONCURRENT_JOBS || rawMap.CAMUNDA_WORKER_REQUEST_TIMEOUT || rawMap.CAMUNDA_WORKER_NAME || rawMap.CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS ? {
@@ -6700,7 +6901,7 @@ function installAuthInterceptor(client2, getStrategy, getAuthHeaders) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.15";
+var packageVersion = "10.0.0-alpha.16";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -7810,12 +8011,12 @@ var ThreadedJobWorker = class {
     this._client = client2;
     this._pool = pool;
     this._cfg = {
-      pollIntervalMs: 1,
-      autoStart: true,
-      validateSchemas: false,
-      maxParallelJobs: 10,
-      jobTimeoutMs: 6e4,
-      ...cfg
+      ...cfg,
+      pollIntervalMs: cfg.pollIntervalMs ?? 1,
+      autoStart: cfg.autoStart ?? true,
+      validateSchemas: cfg.validateSchemas ?? false,
+      maxParallelJobs: cfg.maxParallelJobs ?? 10,
+      jobTimeoutMs: cfg.jobTimeoutMs ?? 6e4
     };
     this._maxParallelJobs = this._cfg.maxParallelJobs;
     this._jobTimeoutMs = this._cfg.jobTimeoutMs;
@@ -8373,7 +8574,7 @@ function deepFreeze2(obj) {
   }
   return obj;
 }
-var VOID_RESPONSES = /* @__PURE__ */ new Set(["zUpdateAgentInstanceResponse", "zDeleteAuthorizationResponse", "zUpdateAuthorizationResponse", "zCancelBatchOperationResponse", "zResumeBatchOperationResponse", "zSuspendBatchOperationResponse", "zPinClockResponse", "zResetClockResponse", "zDeleteGlobalClusterVariableResponse", "zDeleteTenantClusterVariableResponse", "zDeleteDecisionInstanceResponse", "zDeleteDocumentResponse", "zActivateAdHocSubProcessActivitiesResponse", "zCreateElementInstanceVariablesResponse", "zDeleteGlobalTaskListenerResponse", "zDeleteGroupResponse", "zUnassignClientFromGroupResponse", "zAssignClientToGroupResponse", "zUnassignMappingRuleFromGroupResponse", "zAssignMappingRuleToGroupResponse", "zUnassignUserFromGroupResponse", "zAssignUserToGroupResponse", "zResolveIncidentResponse", "zUpdateJobResponse", "zCompleteJobResponse", "zThrowJobErrorResponse", "zFailJobResponse", "zDeleteMappingRuleResponse", "zCancelProcessInstanceResponse", "zDeleteProcessInstanceResponse", "zMigrateProcessInstanceResponse", "zModifyProcessInstanceResponse", "zDeleteRoleResponse", "zUnassignRoleFromClientResponse", "zAssignRoleToClientResponse", "zUnassignRoleFromGroupResponse", "zAssignRoleToGroupResponse", "zUnassignRoleFromMappingRuleResponse", "zAssignRoleToMappingRuleResponse", "zUnassignRoleFromUserResponse", "zAssignRoleToUserResponse", "zGetStatusResponse", "zDeleteTenantResponse", "zUnassignClientFromTenantResponse", "zAssignClientToTenantResponse", "zUnassignGroupFromTenantResponse", "zAssignGroupToTenantResponse", "zUnassignMappingRuleFromTenantResponse", "zAssignMappingRuleToTenantResponse", "zUnassignRoleFromTenantResponse", "zAssignRoleToTenantResponse", "zUnassignUserFromTenantResponse", "zAssignUserToTenantResponse", "zDeleteUserResponse", "zUpdateUserTaskResponse", "zUnassignUserTaskResponse", "zAssignUserTaskResponse", "zCompleteUserTaskResponse"]);
+var VOID_RESPONSES = /* @__PURE__ */ new Set(["zUpdateAgentInstanceResponse", "zDeleteAuthorizationResponse", "zUpdateAuthorizationResponse", "zCancelBatchOperationResponse", "zResumeBatchOperationResponse", "zSuspendBatchOperationResponse", "zPinClockResponse", "zResetClockResponse", "zDeleteGlobalClusterVariableResponse", "zDeleteTenantClusterVariableResponse", "zDeleteDecisionInstanceResponse", "zDeleteDocumentResponse", "zActivateAdHocSubProcessActivitiesResponse", "zCreateElementInstanceVariablesResponse", "zDeleteGlobalTaskListenerResponse", "zDeleteGroupResponse", "zUnassignClientFromGroupResponse", "zAssignClientToGroupResponse", "zUnassignMappingRuleFromGroupResponse", "zAssignMappingRuleToGroupResponse", "zUnassignUserFromGroupResponse", "zAssignUserToGroupResponse", "zResolveIncidentResponse", "zUpdateJobResponse", "zCompleteJobResponse", "zThrowJobErrorResponse", "zFailJobResponse", "zDeleteMappingRuleResponse", "zAssignProcessInstanceBusinessIdResponse", "zCancelProcessInstanceResponse", "zDeleteProcessInstanceResponse", "zMigrateProcessInstanceResponse", "zModifyProcessInstanceResponse", "zResumeProcessInstanceResponse", "zSuspendProcessInstanceResponse", "zDeleteRoleResponse", "zUnassignRoleFromClientResponse", "zAssignRoleToClientResponse", "zUnassignRoleFromGroupResponse", "zAssignRoleToGroupResponse", "zUnassignRoleFromMappingRuleResponse", "zAssignRoleToMappingRuleResponse", "zUnassignRoleFromUserResponse", "zAssignRoleToUserResponse", "zGetStatusResponse", "zDeleteTenantResponse", "zUnassignClientFromTenantResponse", "zAssignClientToTenantResponse", "zUnassignGroupFromTenantResponse", "zAssignGroupToTenantResponse", "zUnassignMappingRuleFromTenantResponse", "zAssignMappingRuleToTenantResponse", "zUnassignRoleFromTenantResponse", "zAssignRoleToTenantResponse", "zUnassignUserFromTenantResponse", "zAssignUserToTenantResponse", "zDeleteUserResponse", "zUpdateUserTaskResponse", "zUnassignUserTaskResponse", "zAssignUserTaskResponse", "zCompleteUserTaskResponse"]);
 var CancelError = class extends Error {
   constructor() {
     super("Cancelled");
@@ -8677,7 +8878,7 @@ var CamundaClient = class {
   _schemasPromise = null;
   _loadSchemas() {
     if (!this._schemasPromise) {
-      this._schemasPromise = import("./zod.gen-2Z6CY4DY.js");
+      this._schemasPromise = import("./zod.gen-EOOTXFM5.js");
     }
     return this._schemasPromise;
   }
@@ -9128,6 +9329,60 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "assignMappingRuleToTenant", exempt: false, retryOverride: options?.retry });
     });
   }
+  assignProcessInstanceBusinessId(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { processInstanceKey, ..._body } = arg || {};
+      let envelope = {};
+      envelope.path = { processInstanceKey };
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("assignProcessInstanceBusinessId", _schemas.zAssignProcessInstanceBusinessIdData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.path) opts.path = envelope.path;
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await assignProcessInstanceBusinessId(opts);
+          let data = this._evaluateResponse(_raw, "assignProcessInstanceBusinessId", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zAssignProcessInstanceBusinessIdResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zAssignProcessInstanceBusinessIdResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("assignProcessInstanceBusinessId", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "assignProcessInstanceBusinessId", exempt: false, retryOverride: options?.retry });
+    });
+  }
   assignRoleToClient(arg, options) {
     return toCancelable2(async (signal) => {
       const { roleId, clientId } = arg || {};
@@ -9762,20 +10017,72 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "cancelProcessInstancesBatchOperation", exempt: false, retryOverride: options?.retry });
     });
   }
-  completeJob(arg, options) {
+  changeClusterMode(arg, options) {
     return toCancelable2(async (signal) => {
-      const { jobKey, ..._body } = arg || {};
+      const { mode, dryRun } = arg || {};
       let envelope = {};
-      envelope.path = { jobKey };
-      envelope.body = _body;
+      envelope.query = { mode, dryRun };
       if (this._validation.settings.req !== "none") {
         const _schemas = await this._loadSchemas();
-        const maybe = await this._validation.gateRequest("completeJob", _schemas.zCompleteJobData, envelope);
+        const maybe = await this._validation.gateRequest("changeClusterMode", _schemas.zChangeClusterModeData, envelope);
         if (this._validation.settings.req === "strict") envelope = maybe;
       }
       const opts = { client: this._client, signal, throwOnError: false };
-      if (envelope.path) opts.path = envelope.path;
-      if (envelope.body !== void 0) opts.body = envelope.body;
+      if (envelope.query) opts.query = envelope.query;
+      const call = async () => {
+        try {
+          const _raw = await changeClusterMode(opts);
+          let data = this._evaluateResponse(_raw, "changeClusterMode", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zChangeClusterModeResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zChangeClusterModeResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("changeClusterMode", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "changeClusterMode", exempt: false, retryOverride: options?.retry });
+    });
+  }
+  completeJob(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { jobKey, ..._body } = arg || {};
+      let envelope = {};
+      envelope.path = { jobKey };
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("completeJob", _schemas.zCompleteJobData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.path) opts.path = envelope.path;
+      if (envelope.body !== void 0) opts.body = envelope.body;
       const call = async () => {
         try {
           const _raw = await completeJob(opts);
@@ -15276,6 +15583,110 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "resolveProcessInstanceIncidents", exempt: false, retryOverride: options?.retry });
     });
   }
+  resolveSecrets(arg, options) {
+    return toCancelable2(async (signal) => {
+      const _body = arg;
+      let envelope = {};
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("resolveSecrets", _schemas.zResolveSecretsData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await resolveSecrets(opts);
+          let data = this._evaluateResponse(_raw, "resolveSecrets", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zResolveSecretsResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zResolveSecretsResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("resolveSecrets", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "resolveSecrets", exempt: false, retryOverride: options?.retry });
+    });
+  }
+  restore(arg, options) {
+    return toCancelable2(async (signal) => {
+      const _body = arg;
+      let envelope = {};
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("restore", _schemas.zRestoreData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await restore(opts);
+          let data = this._evaluateResponse(_raw, "restore", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zRestoreResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zRestoreResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("restore", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "restore", exempt: false, retryOverride: options?.retry });
+    });
+  }
   resumeBatchOperation(arg, options) {
     return toCancelable2(async (signal) => {
       const { batchOperationKey, ..._body } = arg || {};
@@ -15330,6 +15741,112 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "resumeBatchOperation", exempt: false, retryOverride: options?.retry });
     });
   }
+  resumeProcessInstance(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { processInstanceKey, ..._body } = arg || {};
+      let envelope = {};
+      envelope.path = { processInstanceKey };
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("resumeProcessInstance", _schemas.zResumeProcessInstanceData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.path) opts.path = envelope.path;
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await resumeProcessInstance(opts);
+          let data = this._evaluateResponse(_raw, "resumeProcessInstance", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zResumeProcessInstanceResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zResumeProcessInstanceResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("resumeProcessInstance", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "resumeProcessInstance", exempt: false, retryOverride: options?.retry });
+    });
+  }
+  resumeProcessInstancesBatchOperation(arg, options) {
+    return toCancelable2(async (signal) => {
+      const _body = arg;
+      let envelope = {};
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("resumeProcessInstancesBatchOperation", _schemas.zResumeProcessInstancesBatchOperationData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await resumeProcessInstancesBatchOperation(opts);
+          let data = this._evaluateResponse(_raw, "resumeProcessInstancesBatchOperation", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zResumeProcessInstancesBatchOperationResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zResumeProcessInstancesBatchOperationResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("resumeProcessInstancesBatchOperation", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "resumeProcessInstancesBatchOperation", exempt: false, retryOverride: options?.retry });
+    });
+  }
   searchAgentInstanceHistory(arg, consistencyManagement, options) {
     if (!consistencyManagement) throw new Error("Missing consistencyManagement parameter for eventually consistent endpoint");
     const useConsistency = consistencyManagement.consistency;
@@ -16976,6 +17493,64 @@ var CamundaClient = class {
       return invoke();
     });
   }
+  searchProcessDefinitionVariableNames(arg, consistencyManagement, options) {
+    if (!consistencyManagement) throw new Error("Missing consistencyManagement parameter for eventually consistent endpoint");
+    const useConsistency = consistencyManagement.consistency;
+    return toCancelable2(async (signal) => {
+      const { processDefinitionKey, ..._body } = arg || {};
+      let envelope = {};
+      envelope.path = { processDefinitionKey };
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("searchProcessDefinitionVariableNames", _schemas.zSearchProcessDefinitionVariableNamesData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.path) opts.path = envelope.path;
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await searchProcessDefinitionVariableNames(opts);
+          let data = this._evaluateResponse(_raw, "searchProcessDefinitionVariableNames", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zSearchProcessDefinitionVariableNamesResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zSearchProcessDefinitionVariableNamesResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("searchProcessDefinitionVariableNames", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      const invoke = () => toCancelable2(() => call());
+      if (useConsistency) return eventualPoll("searchProcessDefinitionVariableNames", false, invoke, { ...useConsistency, logger: this._log });
+      return invoke();
+    });
+  }
   searchProcessInstanceIncidents(arg, consistencyManagement, options) {
     if (!consistencyManagement) throw new Error("Missing consistencyManagement parameter for eventually consistent endpoint");
     const useConsistency = consistencyManagement.consistency;
@@ -17950,6 +18525,112 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "suspendBatchOperation", exempt: false, retryOverride: options?.retry });
     });
   }
+  suspendProcessInstance(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { processInstanceKey, ..._body } = arg || {};
+      let envelope = {};
+      envelope.path = { processInstanceKey };
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("suspendProcessInstance", _schemas.zSuspendProcessInstanceData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.path) opts.path = envelope.path;
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await suspendProcessInstance(opts);
+          let data = this._evaluateResponse(_raw, "suspendProcessInstance", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zSuspendProcessInstanceResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zSuspendProcessInstanceResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("suspendProcessInstance", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "suspendProcessInstance", exempt: false, retryOverride: options?.retry });
+    });
+  }
+  suspendProcessInstancesBatchOperation(arg, options) {
+    return toCancelable2(async (signal) => {
+      const _body = arg;
+      let envelope = {};
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        const maybe = await this._validation.gateRequest("suspendProcessInstancesBatchOperation", _schemas.zSuspendProcessInstancesBatchOperationData, envelope);
+        if (this._validation.settings.req === "strict") envelope = maybe;
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await suspendProcessInstancesBatchOperation(opts);
+          let data = this._evaluateResponse(_raw, "suspendProcessInstancesBatchOperation", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zSuspendProcessInstancesBatchOperationResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zSuspendProcessInstancesBatchOperationResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("suspendProcessInstancesBatchOperation", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "suspendProcessInstancesBatchOperation", exempt: false, retryOverride: options?.retry });
+    });
+  }
   throwJobError(arg, options) {
     return toCancelable2(async (signal) => {
       const { jobKey, ..._body } = arg || {};
@@ -19752,4 +20433,4 @@ export {
   withTimeoutTE,
   eventuallyTE
 };
-//# sourceMappingURL=chunk-BDHUY2UM.js.map
+//# sourceMappingURL=chunk-RTRUW7ZX.js.map