@camunda8/orchestration-cluster-api 8.9.0-alpha.13 → 8.9.0-alpha.14

package/dist/{chunk-ULXL7H75.js → chunk-G5VLLLLV.js}

@@ -1508,7 +1508,7 @@ var deleteDecisionInstance = (options) => {
   return (options.client ?? client).post({
     requestValidator: void 0,
     responseValidator: void 0,
-    url: "/decision-instances/{decisionInstanceKey}/deletion",
+    url: "/decision-instances/{decisionEvaluationKey}/deletion",
     ...options,
     headers: {
       "Content-Type": "application/json",
@@ -2063,6 +2063,18 @@ var getJobTimeSeriesStatistics = (options) => {
     }
   });
 };
+var getJobErrorStatistics = (options) => {
+  return (options.client ?? client).post({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    url: "/jobs/statistics/errors",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var getLicense = (options) => {
   return (options?.client ?? client).get({
     requestValidator: void 0,
@@ -2659,6 +2671,14 @@ var getUsageMetrics = (options) => {
     ...options
   });
 };
+var getSystemConfiguration = (options) => {
+  return (options?.client ?? client).get({
+    requestValidator: void 0,
+    responseValidator: void 0,
+    url: "/system/configuration",
+    ...options
+  });
+};
 var createTenant = (options) => {
   return (options.client ?? client).post({
     requestValidator: void 0,
@@ -3356,6 +3376,7 @@ __export(zod_gen_exports, {
   zEvaluatedDecisionResult: () => zEvaluatedDecisionResult,
   zExpressionEvaluationRequest: () => zExpressionEvaluationRequest,
   zExpressionEvaluationResult: () => zExpressionEvaluationResult,
+  zExpressionEvaluationWarningItem: () => zExpressionEvaluationWarningItem,
   zFailJobData: () => zFailJobData,
   zFailJobResponse: () => zFailJobResponse,
   zFormId: () => zFormId,
@@ -3395,6 +3416,8 @@ __export(zod_gen_exports, {
   zGetGroupResponse: () => zGetGroupResponse,
   zGetIncidentData: () => zGetIncidentData,
   zGetIncidentResponse: () => zGetIncidentResponse,
+  zGetJobErrorStatisticsData: () => zGetJobErrorStatisticsData,
+  zGetJobErrorStatisticsResponse: () => zGetJobErrorStatisticsResponse,
   zGetJobTimeSeriesStatisticsData: () => zGetJobTimeSeriesStatisticsData,
   zGetJobTimeSeriesStatisticsResponse: () => zGetJobTimeSeriesStatisticsResponse,
   zGetJobTypeStatisticsData: () => zGetJobTypeStatisticsData,
@@ -3439,6 +3462,8 @@ __export(zod_gen_exports, {
   zGetStartProcessFormResponse: () => zGetStartProcessFormResponse,
   zGetStatusData: () => zGetStatusData,
   zGetStatusResponse: () => zGetStatusResponse,
+  zGetSystemConfigurationData: () => zGetSystemConfigurationData,
+  zGetSystemConfigurationResponse: () => zGetSystemConfigurationResponse,
   zGetTenantClusterVariableData: () => zGetTenantClusterVariableData,
   zGetTenantClusterVariableResponse: () => zGetTenantClusterVariableResponse,
   zGetTenantData: () => zGetTenantData,
@@ -3519,6 +3544,10 @@ __export(zod_gen_exports, {
   zJobChangeset: () => zJobChangeset,
   zJobCompletionRequest: () => zJobCompletionRequest,
   zJobErrorRequest: () => zJobErrorRequest,
+  zJobErrorStatisticsFilter: () => zJobErrorStatisticsFilter,
+  zJobErrorStatisticsItem: () => zJobErrorStatisticsItem,
+  zJobErrorStatisticsQuery: () => zJobErrorStatisticsQuery,
+  zJobErrorStatisticsQueryResult: () => zJobErrorStatisticsQueryResult,
   zJobFailRequest: () => zJobFailRequest,
   zJobFilter: () => zJobFilter,
   zJobKey: () => zJobKey,
@@ -3530,6 +3559,7 @@ __export(zod_gen_exports, {
   zJobListenerEventTypeEnum: () => zJobListenerEventTypeEnum,
   zJobListenerEventTypeExactMatch: () => zJobListenerEventTypeExactMatch,
   zJobListenerEventTypeFilterProperty: () => zJobListenerEventTypeFilterProperty,
+  zJobMetricsConfigurationResponse: () => zJobMetricsConfigurationResponse,
   zJobResult: () => zJobResult,
   zJobResultActivateElement: () => zJobResultActivateElement,
   zJobResultAdHocSubProcess: () => zJobResultAdHocSubProcess,
@@ -3808,6 +3838,7 @@ __export(zod_gen_exports, {
   zStringFilterProperty: () => zStringFilterProperty,
   zSuspendBatchOperationData: () => zSuspendBatchOperationData,
   zSuspendBatchOperationResponse: () => zSuspendBatchOperationResponse,
+  zSystemConfigurationResponse: () => zSystemConfigurationResponse,
   zTag: () => zTag,
   zTagSet: () => zTagSet,
   zTenantClientResult: () => zTenantClientResult,
@@ -4133,18 +4164,18 @@ var zAuthorizationFilter = z.object({
   description: "Authorization search filter."
 });
 var zBatchOperationError = z.object({
-  partitionId: z.optional(z.int().register(z.globalRegistry, {
+  partitionId: z.int().register(z.globalRegistry, {
     description: "The partition ID where the error occurred."
-  })),
-  type: z.optional(z.enum([
+  }),
+  type: z.enum([
     "QUERY_FAILED",
     "RESULT_BUFFER_SIZE_EXCEEDED"
   ]).register(z.globalRegistry, {
     description: "The type of the error that occurred during the batch operation."
-  })),
-  message: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  message: z.string().register(z.globalRegistry, {
     description: "The error message that occurred during the batch operation."
-  }))
+  })
 });
 var zBatchOperationItemStateEnum = z.enum([
   "ACTIVE",
@@ -4274,10 +4305,10 @@ var zTopologyResponse = z.object({
   brokers: z.array(zBrokerInfo).register(z.globalRegistry, {
     description: "A list of brokers that are part of this cluster."
   }),
-  clusterId: z.optional(z.union([
+  clusterId: z.union([
     z.string(),
     z.null()
-  ])),
+  ]),
   clusterSize: z.int().register(z.globalRegistry, {
     description: "The number of brokers in the cluster."
   }),
@@ -4303,28 +4334,28 @@ var zEndCursor = z.string().regex(/^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}(?
   description: "The end cursor in a search query result set."
 });
 var zEvaluatedDecisionInputItem = z.object({
-  inputId: z.optional(z.string().register(z.globalRegistry, {
+  inputId: z.string().register(z.globalRegistry, {
     description: "The identifier of the decision input."
-  })),
-  inputName: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  inputName: z.string().register(z.globalRegistry, {
     description: "The name of the decision input."
-  })),
-  inputValue: z.optional(z.string().register(z.globalRegistry, {
-    description: "The description of the decision input."
-  }))
+  }),
+  inputValue: z.string().register(z.globalRegistry, {
+    description: "The value of the decision input."
+  })
 }).register(z.globalRegistry, {
   description: "A decision input that was evaluated within this decision evaluation."
 });
 var zEvaluatedDecisionOutputItem = z.object({
-  outputId: z.optional(z.string().register(z.globalRegistry, {
+  outputId: z.string().register(z.globalRegistry, {
     description: "The ID of the evaluated decison output item."
-  })),
-  outputName: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  outputName: z.string().register(z.globalRegistry, {
     description: "The name of the of the evaluated decison output item."
-  })),
-  outputValue: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  outputValue: z.string().register(z.globalRegistry, {
     description: "The value of the evaluated decison output item."
-  })),
+  }),
   ruleId: z.union([
     z.string(),
     z.null()
@@ -4337,12 +4368,12 @@ var zEvaluatedDecisionOutputItem = z.object({
   description: "The evaluated decision outputs."
 });
 var zMatchedDecisionRuleItem = z.object({
-  ruleId: z.optional(z.string().register(z.globalRegistry, {
+  ruleId: z.string().register(z.globalRegistry, {
     description: "The ID of the matched rule."
-  })),
-  ruleIndex: z.optional(z.int().register(z.globalRegistry, {
+  }),
+  ruleIndex: z.int().register(z.globalRegistry, {
     description: "The index of the matched rule."
-  })),
+  }),
   evaluatedOutputs: z.array(zEvaluatedDecisionOutputItem).register(z.globalRegistry, {
     description: "The evaluated decision outputs."
   })
@@ -4366,18 +4397,18 @@ var zDecisionInstanceStateEnum = z.enum([
   description: "The state of the decision instance. UNSPECIFIED and UNKNOWN are deprecated and should not be used anymore, for removal in 8.10"
 });
 var zDocumentCreationFailureDetail = z.object({
-  fileName: z.optional(z.string().register(z.globalRegistry, {
+  fileName: z.string().register(z.globalRegistry, {
     description: "The name of the file that failed to upload."
-  })),
-  status: z.optional(z.int().register(z.globalRegistry, {
+  }),
+  status: z.int().register(z.globalRegistry, {
     description: "The HTTP status code of the failure."
-  })),
-  title: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  title: z.string().register(z.globalRegistry, {
     description: "A short, human-readable summary of the problem type."
-  })),
-  detail: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  detail: z.string().register(z.globalRegistry, {
     description: "A human-readable explanation specific to this occurrence of the problem."
-  }))
+  })
 });
 var zDocumentLinkRequest = z.object({
   timeToLive: z.optional(z.coerce.bigint().register(z.globalRegistry, {
@@ -4414,6 +4445,11 @@ var zExpressionEvaluationRequest = z.object({
     z.null()
   ]))
 });
+var zExpressionEvaluationWarningItem = z.object({
+  message: z.string().register(z.globalRegistry, {
+    description: "The warning message"
+  })
+});
 var zExpressionEvaluationResult = z.object({
   expression: z.string().register(z.globalRegistry, {
     description: "The evaluated expression"
@@ -4421,7 +4457,7 @@ var zExpressionEvaluationResult = z.object({
   result: z.unknown().register(z.globalRegistry, {
     description: "The result value. Its type can vary."
   }),
-  warnings: z.array(z.string()).register(z.globalRegistry, {
+  warnings: z.array(zExpressionEvaluationWarningItem).register(z.globalRegistry, {
     description: "List of warnings generated during expression evaluation"
   })
 });
@@ -4809,7 +4845,7 @@ var zGroupClientResult = z.object({
     description: "The ID of the client."
   })
 });
-var zProcessDefinitionId = z.string().min(1).regex(/^[a-zA-Z_][a-zA-Z0-9_\-\.]*$/).register(z.globalRegistry, {
+var zProcessDefinitionId = z.string().min(1).regex(/^[\p{L}_][\p{L}\p{N}_\-\.]*$/u).register(z.globalRegistry, {
   description: "Id of a process definition, from the model. Only ids of process definitions that are deployed are useful."
 });
 var zElementId = z.string().register(z.globalRegistry, {
@@ -4838,7 +4874,7 @@ var zAdHocSubProcessActivateActivitiesInstruction = z.object({
 var zFormId = z.string().register(z.globalRegistry, {
   description: "The user-defined id for the form"
 });
-var zDecisionDefinitionId = z.string().min(1).max(256).regex(/^[A-Za-z0-9_@.+-]+$/).register(z.globalRegistry, {
+var zDecisionDefinitionId = z.string().min(1).regex(/^[\p{L}_][\p{L}\p{N}_\-\.]*$/u).register(z.globalRegistry, {
   description: "Id of a decision definition, from the model. Only ids of decision definitions that are deployed are useful."
 });
 var zGlobalListenerId = z.string().register(z.globalRegistry, {
@@ -4940,15 +4976,15 @@ var zAdvancedIncidentStateFilter = z.object({
   description: "Advanced IncidentStateEnum filter"
 });
 var zIncidentProcessInstanceStatisticsByErrorResult = z.object({
-  errorHashCode: z.optional(z.int().register(z.globalRegistry, {
+  errorHashCode: z.int().register(z.globalRegistry, {
     description: "The hash code identifying a specific incident error.."
-  })),
-  errorMessage: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  errorMessage: z.string().register(z.globalRegistry, {
     description: "The error message associated with the incident error hash code."
-  })),
-  activeInstancesWithErrorCount: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  }),
+  activeInstancesWithErrorCount: z.coerce.bigint().register(z.globalRegistry, {
     description: "The number of active process instances that currently have an active incident with this error.\n"
-  }))
+  })
 });
 var zIncidentProcessInstanceStatisticsByDefinitionFilter = z.object({
   errorHashCode: z.int().register(z.globalRegistry, {
@@ -5017,7 +5053,7 @@ var zJobWorkerStatisticsFilter = z.object({
 });
 var zJobWorkerStatisticsItem = z.object({
   worker: z.string().register(z.globalRegistry, {
-    description: "The worker identifier."
+    description: "The name of the worker activating the jobs, mostly used for logging purposes."
   }),
   created: zStatusMetric,
   completed: zStatusMetric,
@@ -5051,6 +5087,34 @@ var zJobTimeSeriesStatisticsItem = z.object({
 }).register(z.globalRegistry, {
   description: "Aggregated job metrics for a single time bucket."
 });
+var zJobErrorStatisticsFilter = z.object({
+  from: z.iso.datetime().register(z.globalRegistry, {
+    description: "Start of the time window to filter metrics. ISO 8601 date-time format.\n"
+  }),
+  to: z.iso.datetime().register(z.globalRegistry, {
+    description: "End of the time window to filter metrics. ISO 8601 date-time format.\n"
+  }),
+  jobType: z.string().register(z.globalRegistry, {
+    description: "Job type to return error metrics for."
+  }),
+  errorCode: z.optional(zStringFilterProperty),
+  errorMessage: z.optional(zStringFilterProperty)
+}).register(z.globalRegistry, {
+  description: "Job error statistics search filter."
+});
+var zJobErrorStatisticsItem = z.object({
+  errorCode: z.string().register(z.globalRegistry, {
+    description: "The error code identifier."
+  }),
+  errorMessage: z.string().register(z.globalRegistry, {
+    description: "The error message."
+  }),
+  workers: z.int().register(z.globalRegistry, {
+    description: "Number of distinct workers that encountered this error."
+  })
+}).register(z.globalRegistry, {
+  description: "Aggregated error metrics for a single error type and message combination."
+});
 var zJobFailRequest = z.object({
   retries: z.optional(z.int().register(z.globalRegistry, {
     description: "The amount of retries the job should have left"
@@ -5404,8 +5468,8 @@ var zConditionalEvaluationInstruction = z.object({
   })
 });
 var zProcessInstanceReference = z.object({
-  processDefinitionKey: z.optional(zProcessDefinitionKey),
-  processInstanceKey: z.optional(zProcessInstanceKey)
+  processDefinitionKey: zProcessDefinitionKey,
+  processInstanceKey: zProcessInstanceKey
 });
 var zEvaluateConditionalResult = z.object({
   conditionalEvaluationKey: zConditionalEvaluationKey,
@@ -5428,32 +5492,32 @@ var zDeploymentProcessResult = z.object({
   description: "A deployed process."
 });
 var zIncidentProcessInstanceStatisticsByDefinitionResult = z.object({
-  processDefinitionId: z.optional(zProcessDefinitionId),
-  processDefinitionKey: z.optional(zProcessDefinitionKey),
-  processDefinitionName: z.optional(z.string().register(z.globalRegistry, {
+  processDefinitionId: zProcessDefinitionId,
+  processDefinitionKey: zProcessDefinitionKey,
+  processDefinitionName: z.string().register(z.globalRegistry, {
     description: "The name of the process definition."
-  })),
-  processDefinitionVersion: z.optional(z.int().register(z.globalRegistry, {
+  }),
+  processDefinitionVersion: z.int().register(z.globalRegistry, {
     description: "The version of the process definition."
-  })),
-  tenantId: z.optional(zTenantId),
-  activeInstancesWithErrorCount: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  }),
+  tenantId: zTenantId,
+  activeInstancesWithErrorCount: z.coerce.bigint().register(z.globalRegistry, {
     description: "The number of active process instances that currently have an incident\nwith the specified error hash code.\n"
-  }))
+  })
 });
 var zElementInstanceKey = zLongKey;
 var zUserTaskKey = zLongKey;
 var zFormKey = zLongKey;
 var zDeploymentFormResult = z.object({
-  formId: z.optional(zFormId),
-  version: z.optional(z.int().register(z.globalRegistry, {
+  formId: zFormId,
+  version: z.int().register(z.globalRegistry, {
     description: "The version of the deployed form."
-  })),
-  resourceName: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  resourceName: z.string().register(z.globalRegistry, {
     description: "The name of the resource."
-  })),
-  tenantId: z.optional(zTenantId),
-  formKey: z.optional(zFormKey)
+  }),
+  tenantId: zTenantId,
+  formKey: zFormKey
 }).register(z.globalRegistry, {
   description: "A deployed form."
 });
@@ -5469,13 +5533,13 @@ var zFormResult = z.object({
   formKey: zFormKey
 });
 var zUserTaskProperties = z.object({
-  action: z.optional(z.string().register(z.globalRegistry, {
+  action: z.string().register(z.globalRegistry, {
     description: "The action performed on the user task."
-  })),
-  assignee: z.optional(z.union([
+  }),
+  assignee: z.union([
     z.string(),
     z.null()
-  ])),
+  ]),
   candidateGroups: z.array(z.string()).register(z.globalRegistry, {
     description: "The groups eligible to claim the task."
   }),
@@ -5485,23 +5549,26 @@ var zUserTaskProperties = z.object({
   changedAttributes: z.array(z.string()).register(z.globalRegistry, {
     description: "The attributes that were changed in the task."
   }),
-  dueDate: z.optional(z.union([
+  dueDate: z.union([
     z.string(),
     z.null()
-  ])),
-  followUpDate: z.optional(z.union([
+  ]),
+  followUpDate: z.union([
     z.string(),
     z.null()
-  ])),
-  formKey: z.optional(zFormKey),
-  priority: z.optional(z.union([
+  ]),
+  formKey: z.union([
+    zFormKey,
+    z.null()
+  ]),
+  priority: z.union([
     z.int().gte(0).lte(100),
     z.null()
-  ])),
-  userTaskKey: z.optional(z.union([
+  ]),
+  userTaskKey: z.union([
     zUserTaskKey,
     z.null()
-  ]))
+  ])
 }).register(z.globalRegistry, {
   description: "Contains properties of a user task."
 });
@@ -5513,10 +5580,10 @@ var zElementInstanceResult = z.object({
   startDate: z.iso.datetime().register(z.globalRegistry, {
     description: "Date when element instance started."
   }),
-  endDate: z.optional(z.union([
+  endDate: z.union([
     z.iso.datetime(),
     z.null()
-  ])),
+  ]),
   elementId: zElementId,
   elementName: z.string().register(z.globalRegistry, {
     description: "The element name for this element instance."
@@ -5564,10 +5631,10 @@ var zElementInstanceResult = z.object({
     z.null()
   ]),
   processDefinitionKey: zProcessDefinitionKey,
-  incidentKey: z.optional(z.union([
+  incidentKey: z.union([
     zIncidentKey,
     z.null()
-  ]))
+  ])
 });
 var zJobKey = zLongKey;
 var zIncidentResult = z.object({
@@ -5626,10 +5693,10 @@ var zActivatedJobResult = z.object({
   elementInstanceKey: zElementInstanceKey,
   kind: zJobKindEnum,
   listenerEventType: zJobListenerEventTypeEnum,
-  userTask: z.optional(z.union([
+  userTask: z.union([
     zUserTaskProperties,
     z.null()
-  ])),
+  ]),
   tags: zTagSet,
   rootProcessInstanceKey: z.union([
     zProcessInstanceKey,
@@ -5647,38 +5714,38 @@ var zJobSearchResult = z.object({
   customHeaders: z.record(z.string(), z.string()).register(z.globalRegistry, {
     description: "A set of custom headers defined during modelling."
   }),
-  deadline: z.optional(z.union([
+  deadline: z.union([
     z.iso.datetime(),
     z.null()
-  ])),
-  deniedReason: z.optional(z.union([
+  ]),
+  deniedReason: z.union([
     z.string(),
     z.null()
-  ])),
+  ]),
   elementId: z.union([
     zElementId,
     z.null()
   ]),
   elementInstanceKey: zElementInstanceKey,
-  endTime: z.optional(z.union([
+  endTime: z.union([
     z.iso.datetime(),
     z.null()
-  ])),
-  errorCode: z.optional(z.union([
+  ]),
+  errorCode: z.union([
     z.string(),
     z.null()
-  ])),
-  errorMessage: z.optional(z.union([
+  ]),
+  errorMessage: z.union([
     z.string(),
     z.null()
-  ])),
+  ]),
   hasFailedWithRetriesLeft: z.boolean().register(z.globalRegistry, {
     description: "Indicates whether the job has failed with retries left."
   }),
-  isDenied: z.optional(z.union([
+  isDenied: z.union([
     z.boolean(),
     z.null()
-  ])),
+  ]),
   jobKey: zJobKey,
   kind: zJobKindEnum,
   listenerEventType: zJobListenerEventTypeEnum,
@@ -5700,12 +5767,14 @@ var zJobSearchResult = z.object({
   worker: z.string().register(z.globalRegistry, {
     description: "The name of the worker of this job."
   }),
-  creationTime: z.optional(z.iso.datetime().register(z.globalRegistry, {
-    description: "When the job was created. Field is present for jobs created after 8.9."
-  })),
-  lastUpdateTime: z.optional(z.iso.datetime().register(z.globalRegistry, {
-    description: "When the job was last updated. Field is present for jobs created after 8.9."
-  }))
+  creationTime: z.union([
+    z.iso.datetime(),
+    z.null()
+  ]),
+  lastUpdateTime: z.union([
+    z.iso.datetime(),
+    z.null()
+  ])
 });
 var zDecisionDefinitionKey = zLongKey;
 var zDecisionEvaluationByKey = z.object({
@@ -5721,28 +5790,28 @@ var zDecisionEvaluationInstruction = z.union([
 ]);
 var zDecisionEvaluationInstanceKey = zLongKey;
 var zEvaluatedDecisionResult = z.object({
-  decisionDefinitionId: z.optional(zDecisionDefinitionId),
-  decisionDefinitionName: z.optional(z.string().register(z.globalRegistry, {
+  decisionDefinitionId: zDecisionDefinitionId,
+  decisionDefinitionName: z.string().register(z.globalRegistry, {
     description: "The name of the decision which was evaluated."
-  })),
-  decisionDefinitionVersion: z.optional(z.int().register(z.globalRegistry, {
+  }),
+  decisionDefinitionVersion: z.int().register(z.globalRegistry, {
     description: "The version of the decision which was evaluated."
-  })),
+  }),
   decisionDefinitionType: z.string().register(z.globalRegistry, {
     description: "The type of the decision which was evaluated."
   }),
-  output: z.optional(z.string().register(z.globalRegistry, {
+  output: z.string().register(z.globalRegistry, {
     description: "JSON document that will instantiate the result of the decision which was evaluated.\n"
-  })),
-  tenantId: z.optional(zTenantId),
+  }),
+  tenantId: zTenantId,
   matchedRules: z.array(zMatchedDecisionRuleItem).register(z.globalRegistry, {
     description: "The decision rules that matched within this decision evaluation."
   }),
   evaluatedInputs: z.array(zEvaluatedDecisionInputItem).register(z.globalRegistry, {
     description: "The decision inputs that were evaluated within this decision evaluation."
   }),
-  decisionDefinitionKey: z.optional(zDecisionDefinitionKey),
-  decisionEvaluationInstanceKey: z.optional(zDecisionEvaluationInstanceKey)
+  decisionDefinitionKey: zDecisionDefinitionKey,
+  decisionEvaluationInstanceKey: zDecisionEvaluationInstanceKey
 }).register(z.globalRegistry, {
   description: "A decision that was evaluated."
 });
@@ -5880,37 +5949,37 @@ var zDecisionRequirementsResult = z.object({
   })
 });
 var zDeploymentDecisionResult = z.object({
-  decisionDefinitionId: z.optional(zDecisionDefinitionId),
-  version: z.optional(z.int().register(z.globalRegistry, {
+  decisionDefinitionId: zDecisionDefinitionId,
+  version: z.int().register(z.globalRegistry, {
     description: "The assigned decision version."
-  })),
-  name: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  name: z.string().register(z.globalRegistry, {
     description: "The DMN name of the decision, as parsed during deployment."
-  })),
-  tenantId: z.optional(zTenantId),
-  decisionRequirementsId: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  tenantId: zTenantId,
+  decisionRequirementsId: z.string().register(z.globalRegistry, {
     description: "The dmn ID of the decision requirements graph that this decision is part of, as parsed during deployment.\n"
-  })),
-  decisionDefinitionKey: z.optional(zDecisionDefinitionKey),
-  decisionRequirementsKey: z.optional(zDecisionRequirementsKey)
+  }),
+  decisionDefinitionKey: zDecisionDefinitionKey,
+  decisionRequirementsKey: zDecisionRequirementsKey
 }).register(z.globalRegistry, {
   description: "A deployed decision."
 });
 var zDeploymentDecisionRequirementsResult = z.object({
-  decisionRequirementsId: z.optional(z.string().register(z.globalRegistry, {
+  decisionRequirementsId: z.string().register(z.globalRegistry, {
     description: "The id of the deployed decision requirements."
-  })),
-  decisionRequirementsName: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  decisionRequirementsName: z.string().register(z.globalRegistry, {
     description: "The name of the deployed decision requirements."
-  })),
-  version: z.optional(z.int().register(z.globalRegistry, {
+  }),
+  version: z.int().register(z.globalRegistry, {
     description: "The version of the deployed decision requirements."
-  })),
-  resourceName: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  resourceName: z.string().register(z.globalRegistry, {
     description: "The name of the resource."
-  })),
-  tenantId: z.optional(zTenantId),
-  decisionRequirementsKey: z.optional(zDecisionRequirementsKey)
+  }),
+  tenantId: zTenantId,
+  decisionRequirementsKey: zDecisionRequirementsKey
 }).register(z.globalRegistry, {
   description: "Deployed decision requirements."
 });
@@ -5921,17 +5990,17 @@ var zResourceKey = z.union([
   zDecisionDefinitionKey
 ]);
 var zDeploymentResourceResult = z.object({
-  resourceId: z.optional(z.string().register(z.globalRegistry, {
+  resourceId: z.string().register(z.globalRegistry, {
     description: "The resource id of the deployed resource."
-  })),
-  resourceName: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  resourceName: z.string().register(z.globalRegistry, {
     description: "The name of the deployed resource."
-  })),
-  version: z.optional(z.int().register(z.globalRegistry, {
+  }),
+  version: z.int().register(z.globalRegistry, {
     description: "The description of the deployed resource."
-  })),
-  tenantId: z.optional(zTenantId),
-  resourceKey: z.optional(zResourceKey)
+  }),
+  tenantId: zTenantId,
+  resourceKey: zResourceKey
 }).register(z.globalRegistry, {
   description: "A deployed Resource."
 });
@@ -6041,14 +6110,14 @@ var zBatchOperationResponse = z.object({
   batchOperationKey: zBatchOperationKey,
   state: zBatchOperationStateEnum,
   batchOperationType: zBatchOperationTypeEnum,
-  startDate: z.optional(z.union([
+  startDate: z.union([
     z.iso.datetime(),
     z.null()
-  ])),
-  endDate: z.optional(z.union([
+  ]),
+  endDate: z.union([
     z.iso.datetime(),
     z.null()
-  ])),
+  ]),
   actorType: z.union([
     zAuditLogActorTypeEnum,
     z.null()
@@ -6071,17 +6140,17 @@ var zBatchOperationResponse = z.object({
   })
 });
 var zBatchOperationItemResponse = z.object({
-  operationType: z.optional(zBatchOperationTypeEnum),
-  batchOperationKey: z.optional(zBatchOperationKey),
-  itemKey: z.optional(z.string().register(z.globalRegistry, {
+  operationType: zBatchOperationTypeEnum,
+  batchOperationKey: zBatchOperationKey,
+  itemKey: z.string().register(z.globalRegistry, {
     description: "Key of the item, e.g. a process instance key."
-  })),
-  processInstanceKey: z.optional(zProcessInstanceKey),
+  }),
+  processInstanceKey: zProcessInstanceKey,
   rootProcessInstanceKey: z.union([
     zProcessInstanceKey,
     z.null()
   ]),
-  state: z.optional(z.enum([
+  state: z.enum([
     "ACTIVE",
     "COMPLETED",
     "SKIPPED",
@@ -6089,21 +6158,22 @@ var zBatchOperationItemResponse = z.object({
     "FAILED"
   ]).register(z.globalRegistry, {
     description: "State of the item."
-  })),
-  processedDate: z.optional(z.iso.datetime().register(z.globalRegistry, {
-    description: "the date this item was processed."
-  })),
-  errorMessage: z.optional(z.union([
+  }),
+  processedDate: z.union([
+    z.iso.datetime(),
+    z.null()
+  ]),
+  errorMessage: z.union([
     z.string(),
     z.null()
-  ]))
+  ])
 });
 var zDeleteResourceResponse = z.object({
   resourceKey: zResourceKey,
-  batchOperation: z.optional(z.union([
+  batchOperation: z.union([
     zBatchOperationCreatedResult,
     z.null()
-  ]))
+  ])
 });
 var zOperationReference = z.coerce.bigint().gte(BigInt(1)).register(z.globalRegistry, {
   description: "A reference key chosen by the user that will be part of all records resulting from this operation.\nMust be > 0 if provided.\n"
@@ -6164,10 +6234,6 @@ var zAuditLogResult = z.object({
     z.null()
   ]),
   result: zAuditLogResultEnum,
-  annotation: z.union([
-    z.string(),
-    z.null()
-  ]),
   category: zAuditLogCategoryEnum,
   processDefinitionId: z.union([
     zProcessDefinitionId,
@@ -6557,27 +6623,37 @@ var zAdvancedMessageSubscriptionStateFilter = z.object({
 });
 var zMessageSubscriptionKey = zLongKey;
 var zMessageSubscriptionResult = z.object({
-  messageSubscriptionKey: z.optional(zMessageSubscriptionKey),
-  processDefinitionId: z.optional(zProcessDefinitionId),
-  processDefinitionKey: z.optional(zProcessDefinitionKey),
-  processInstanceKey: z.optional(zProcessInstanceKey),
+  messageSubscriptionKey: zMessageSubscriptionKey,
+  processDefinitionId: zProcessDefinitionId,
+  processDefinitionKey: z.union([
+    zProcessDefinitionKey,
+    z.null()
+  ]),
+  processInstanceKey: z.union([
+    zProcessInstanceKey,
+    z.null()
+  ]),
   rootProcessInstanceKey: z.union([
     zProcessInstanceKey,
     z.null()
   ]),
-  elementId: z.optional(zElementId),
-  elementInstanceKey: z.optional(zElementInstanceKey),
-  messageSubscriptionState: z.optional(zMessageSubscriptionStateEnum),
-  lastUpdatedDate: z.optional(z.iso.datetime().register(z.globalRegistry, {
+  elementId: zElementId,
+  elementInstanceKey: z.union([
+    zElementInstanceKey,
+    z.null()
+  ]),
+  messageSubscriptionState: zMessageSubscriptionStateEnum,
+  lastUpdatedDate: z.iso.datetime().register(z.globalRegistry, {
     description: "The last updated date of the message subscription."
-  })),
-  messageName: z.optional(z.string().register(z.globalRegistry, {
+  }),
+  messageName: z.string().register(z.globalRegistry, {
     description: "The name of the message associated with the message subscription."
-  })),
-  correlationKey: z.optional(z.string().register(z.globalRegistry, {
-    description: "The correlation key of the message subscription."
-  })),
-  tenantId: z.optional(zTenantId)
+  }),
+  correlationKey: z.union([
+    z.string(),
+    z.null()
+  ]),
+  tenantId: zTenantId
 });
 var zAdvancedMessageSubscriptionKeyFilter = z.object({
   "$eq": z.optional(zMessageSubscriptionKey),
@@ -6609,16 +6685,20 @@ var zMessagePublicationResult = z.object({
   description: "The message key of the published message."
 });
 var zCorrelatedMessageSubscriptionResult = z.object({
-  correlationKey: z.string().register(z.globalRegistry, {
-    description: "The correlation key of the message."
-  }),
+  correlationKey: z.union([
+    z.string(),
+    z.null()
+  ]),
   correlationTime: z.iso.datetime().register(z.globalRegistry, {
     description: "The time when the message was correlated."
   }),
   elementId: z.string().register(z.globalRegistry, {
     description: "The element ID that received the message."
   }),
-  elementInstanceKey: z.optional(zElementInstanceKey),
+  elementInstanceKey: z.union([
+    zElementInstanceKey,
+    z.null()
+  ]),
   messageKey: zMessageKey,
   messageName: z.string().register(z.globalRegistry, {
     description: "The name of the message."
@@ -6627,7 +6707,7 @@ var zCorrelatedMessageSubscriptionResult = z.object({
     description: "The partition ID that correlated the message."
   }),
   processDefinitionId: zProcessDefinitionId,
-  processDefinitionKey: z.optional(zProcessDefinitionKey),
+  processDefinitionKey: zProcessDefinitionKey,
   processInstanceKey: zProcessInstanceKey,
   rootProcessInstanceKey: z.union([
     zProcessInstanceKey,
@@ -6701,19 +6781,19 @@ var zProcessDefinitionResult = z.object({
   })
 });
 var zProcessElementStatisticsResult = z.object({
-  elementId: z.optional(zElementId),
-  active: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  elementId: zElementId,
+  active: z.coerce.bigint().register(z.globalRegistry, {
     description: "The total number of active instances of the element."
-  })),
-  canceled: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  }),
+  canceled: z.coerce.bigint().register(z.globalRegistry, {
     description: "The total number of canceled instances of the element."
-  })),
-  incidents: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  }),
+  incidents: z.coerce.bigint().register(z.globalRegistry, {
     description: "The total number of incidents for the element."
-  })),
-  completed: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  }),
+  completed: z.coerce.bigint().register(z.globalRegistry, {
     description: "The total number of completed instances of the element."
-  }))
+  })
 }).register(z.globalRegistry, {
   description: "Process element statistics response."
 });
@@ -6725,32 +6805,32 @@ var zProcessDefinitionElementStatisticsQueryResult = z.object({
   description: "Process definition element statistics query response."
 });
 var zProcessDefinitionMessageSubscriptionStatisticsResult = z.object({
-  processDefinitionId: z.optional(zProcessDefinitionId),
-  tenantId: z.optional(zTenantId),
-  processDefinitionKey: z.optional(zProcessDefinitionKey),
-  processInstancesWithActiveSubscriptions: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  processDefinitionId: zProcessDefinitionId,
+  tenantId: zTenantId,
+  processDefinitionKey: zProcessDefinitionKey,
+  processInstancesWithActiveSubscriptions: z.coerce.bigint().register(z.globalRegistry, {
     description: "The number of process instances with active message subscriptions."
-  })),
-  activeSubscriptions: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  }),
+  activeSubscriptions: z.coerce.bigint().register(z.globalRegistry, {
     description: "The total number of active message subscriptions for this process definition key."
-  }))
+  })
 });
 var zProcessDefinitionInstanceStatisticsResult = z.object({
-  processDefinitionId: z.optional(zProcessDefinitionId),
-  tenantId: z.optional(zTenantId),
-  latestProcessDefinitionName: z.optional(z.union([
+  processDefinitionId: zProcessDefinitionId,
+  tenantId: zTenantId,
+  latestProcessDefinitionName: z.union([
     z.string(),
     z.null()
-  ])),
-  hasMultipleVersions: z.optional(z.boolean().register(z.globalRegistry, {
+  ]),
+  hasMultipleVersions: z.boolean().register(z.globalRegistry, {
     description: "Indicates whether multiple versions of this process definition instance are deployed."
-  })),
-  activeInstancesWithoutIncidentCount: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  }),
+  activeInstancesWithoutIncidentCount: z.coerce.bigint().register(z.globalRegistry, {
     description: "Total number of currently active process instances of this definition that do not have incidents."
-  })),
-  activeInstancesWithIncidentCount: z.optional(z.coerce.bigint().register(z.globalRegistry, {
+  }),
+  activeInstancesWithIncidentCount: z.coerce.bigint().register(z.globalRegistry, {
     description: "Total number of currently active process instances of this definition that have at least one incident."
-  }))
+  })
 }).register(z.globalRegistry, {
   description: "Process definition instance statistics response."
 });
@@ -6866,10 +6946,10 @@ var zCreateProcessInstanceResult = z.object({
   processDefinitionKey: zProcessDefinitionKey,
   processInstanceKey: zProcessInstanceKey,
   tags: zTagSet,
-  businessId: z.optional(z.union([
+  businessId: z.union([
     zBusinessId,
     z.null()
-  ]))
+  ])
 });
 var zCancelProcessInstanceRequest = z.union([
   z.object({
@@ -6891,18 +6971,18 @@ var zProcessInstanceCallHierarchyEntry = z.object({
   })
 });
 var zProcessInstanceSequenceFlowResult = z.object({
-  sequenceFlowId: z.optional(z.string().register(z.globalRegistry, {
+  sequenceFlowId: z.string().register(z.globalRegistry, {
     description: "The sequence flow id."
-  })),
-  processInstanceKey: z.optional(zProcessInstanceKey),
+  }),
+  processInstanceKey: zProcessInstanceKey,
   rootProcessInstanceKey: z.union([
     zProcessInstanceKey,
     z.null()
   ]),
-  processDefinitionKey: z.optional(zProcessDefinitionKey),
-  processDefinitionId: z.optional(zProcessDefinitionId),
-  elementId: z.optional(zElementId),
-  tenantId: z.optional(zTenantId)
+  processDefinitionKey: zProcessDefinitionKey,
+  processDefinitionId: zProcessDefinitionId,
+  elementId: zElementId,
+  tenantId: zTenantId
 }).register(z.globalRegistry, {
   description: "Process instance sequence flow result."
 });
@@ -7239,6 +7319,12 @@ var zJobTimeSeriesStatisticsQuery = z.object({
 }).register(z.globalRegistry, {
   description: "Job time-series statistics query."
 });
+var zJobErrorStatisticsQuery = z.object({
+  filter: zJobErrorStatisticsFilter,
+  page: z.optional(zCursorForwardPagination)
+}).register(z.globalRegistry, {
+  description: "Job error statistics query."
+});
 var zCursorBackwardPagination = z.object({
   before: zStartCursor,
   limit: z.optional(z.int().gte(1).lte(1e4).register(z.globalRegistry, {
@@ -7264,7 +7350,6 @@ var zAuditLogSearchQuerySortRequest = z.object({
   field: z.enum([
     "actorId",
     "actorType",
-    "annotation",
     "auditLogKey",
     "batchOperationKey",
     "batchOperationType",
@@ -7489,7 +7574,6 @@ var zIncidentSearchQuerySortRequest = z.object({
     "processDefinitionId",
     "processInstanceKey",
     "errorType",
-    "errorMessage",
     "elementId",
     "elementInstanceKey",
     "creationTime",
@@ -7891,6 +7975,14 @@ var zJobTimeSeriesStatisticsQueryResult = zSearchQueryResponse.and(z.object({
 }).register(z.globalRegistry, {
   description: "Job time-series statistics query result."
 }));
+var zJobErrorStatisticsQueryResult = zSearchQueryResponse.and(z.object({
+  items: z.array(zJobErrorStatisticsItem).register(z.globalRegistry, {
+    description: "The list of per-error statistics items."
+  }),
+  page: zSearchQueryPageResponse
+}).register(z.globalRegistry, {
+  description: "Job error statistics query result."
+}));
 var zJobSearchQueryResult = zSearchQueryResponse.and(z.object({
   items: z.array(zJobSearchResult).register(z.globalRegistry, {
     description: "The matching jobs."
@@ -8000,6 +8092,33 @@ var zUsageMetricsResponse = zUsageMetricsResponseItem.and(z.object({
     description: "The usage metrics by tenants. Only available if request `withTenants` query parameter was `true`."
   })
 }));
+var zJobMetricsConfigurationResponse = z.object({
+  enabled: z.boolean().register(z.globalRegistry, {
+    description: "Whether job metrics export is enabled."
+  }),
+  exportInterval: z.string().register(z.globalRegistry, {
+    description: "The interval at which job metrics are exported, as an ISO 8601 duration."
+  }),
+  maxWorkerNameLength: z.int().register(z.globalRegistry, {
+    description: "The maximum length of the worker name used in job metrics labels."
+  }),
+  maxJobTypeLength: z.int().register(z.globalRegistry, {
+    description: "The maximum length of the job type used in job metrics labels."
+  }),
+  maxTenantIdLength: z.int().register(z.globalRegistry, {
+    description: "The maximum length of the tenant ID used in job metrics labels."
+  }),
+  maxUniqueKeys: z.int().register(z.globalRegistry, {
+    description: "The maximum number of unique metric keys tracked for job metrics."
+  })
+}).register(z.globalRegistry, {
+  description: "Configuration for job metrics collection and export."
+});
+var zSystemConfigurationResponse = z.object({
+  jobMetrics: zJobMetricsConfigurationResponse
+}).register(z.globalRegistry, {
+  description: "Envelope for all system configuration sections. Each property\nrepresents a feature area.\n"
+});
 var zTenantCreateRequest = z.object({
   tenantId: z.string().min(1).max(256).regex(/^[A-Za-z0-9_@.+-]+$/).register(z.globalRegistry, {
     description: "The unique ID for the tenant. Must be 255 characters or less. Can contain letters, numbers, [`_`, `-`, `+`, `.`, `@`]."
@@ -8052,18 +8171,18 @@ var zTenantResult = z.object({
   description: "Tenant search response item."
 });
 var zCamundaUserResult = z.object({
-  username: z.optional(z.union([
+  username: z.union([
     zUsername,
     z.null()
-  ])),
-  displayName: z.optional(z.union([
+  ]),
+  displayName: z.union([
     z.string(),
     z.null()
-  ])),
-  email: z.optional(z.union([
+  ]),
+  email: z.union([
     z.string(),
     z.null()
-  ])),
+  ]),
   authorizedComponents: z.array(z.string()).register(z.globalRegistry, {
     description: "The web components the user is authorized to use."
   }),
@@ -8504,12 +8623,12 @@ var zVariableResultBase = z.object({
   description: "Variable response item."
 });
 var zVariableSearchResult = zVariableResultBase.and(z.object({
-  value: z.optional(z.string().register(z.globalRegistry, {
+  value: z.string().register(z.globalRegistry, {
     description: "Value of this variable. Can be truncated."
-  })),
-  isTruncated: z.optional(z.boolean().register(z.globalRegistry, {
+  }),
+  isTruncated: z.boolean().register(z.globalRegistry, {
     description: "Whether the value is truncated or not."
-  }))
+  })
 }).register(z.globalRegistry, {
   description: "Variable search response item."
 }));
@@ -9117,6 +9236,7 @@ var zBaseProcessInstanceFilterFields = z.object({
   parentProcessInstanceKey: z.optional(zProcessInstanceKeyFilterProperty),
   parentElementInstanceKey: z.optional(zElementInstanceKeyFilterProperty),
   batchOperationId: z.optional(zStringFilterProperty),
+  batchOperationKey: z.optional(zStringFilterProperty),
   errorMessage: z.optional(zStringFilterProperty),
   hasRetriesLeft: z.optional(z.boolean().register(z.globalRegistry, {
     description: "Whether the process has failed jobs with retries left."
@@ -9518,7 +9638,7 @@ var zDeleteDecisionInstanceData = z.object({
     z.null()
   ])),
   path: z.object({
-    decisionInstanceKey: zDecisionInstanceKey
+    decisionEvaluationKey: zDecisionEvaluationKey
   }),
   query: z.optional(z.never())
 });
@@ -10076,6 +10196,12 @@ var zGetJobTimeSeriesStatisticsData = z.object({
   query: z.optional(z.never())
 });
 var zGetJobTimeSeriesStatisticsResponse = zJobTimeSeriesStatisticsQueryResult;
+var zGetJobErrorStatisticsData = z.object({
+  body: zJobErrorStatisticsQuery,
+  path: z.optional(z.never()),
+  query: z.optional(z.never())
+});
+var zGetJobErrorStatisticsResponse = zJobErrorStatisticsQueryResult;
 var zGetLicenseData = z.object({
   body: z.optional(z.never()),
   path: z.optional(z.never()),
@@ -10664,6 +10790,12 @@ var zGetUsageMetricsData = z.object({
   })
 });
 var zGetUsageMetricsResponse = zUsageMetricsResponse;
+var zGetSystemConfigurationData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.never())
+});
+var zGetSystemConfigurationResponse = zSystemConfigurationResponse;
 var zCreateTenantData = z.object({
   body: zTenantCreateRequest,
   path: z.optional(z.never()),
@@ -12426,7 +12558,7 @@ function installAuthInterceptor(client2, getStrategy, getAuthHeaders) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "8.9.0-alpha.13";
+var packageVersion = "8.9.0-alpha.14";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -13372,143 +13504,576 @@ var BackpressureManager = class {
       } else {
         this.backoffMs = Math.min(this.cfg.backoffMaxMs, this.backoffMs * this.cfg.backoffEscalate);
       }
-      this.log("backoff.escalate", { delayMs: this.backoffMs });
+      this.log("backoff.escalate", { delayMs: this.backoffMs });
+    }
+    if (this.severity !== prevSeverity)
+      this.log("severity", { severity: this.severity }, prevSeverity);
+  }
+  recordHealthyHint() {
+    if (!this.cfg.enabled && !this.observeOnly) return;
+    if (this.backoffMs > 0) {
+      this.backoffMs = 0;
+      this.log("backoff.clear", { reason: "healthy-hint" });
+    }
+    const now2 = this.now();
+    this.maybeRecover(now2);
+  }
+  scalePermits(factor) {
+    if (this.permitsMax === null) return;
+    const next = Math.max(this.cfg.floorConcurrency, Math.ceil(this.permitsMax * factor));
+    if (next < this.permitsMax) {
+      this.permitsMax = next;
+      this.log("permits.scale", { max: this.permitsMax });
+    }
+  }
+  maybeRecover(now2 = this.now()) {
+    if (this.permitsMax === null || this.observeOnly) return;
+    if (now2 - this.lastRecoverCheck < this.cfg.recoveryIntervalMs) return;
+    this.lastRecoverCheck = now2;
+    if (now2 - this.lastEventAt > this.cfg.decayQuietMs) {
+      const prev = this.severity;
+      if (this.severity === "severe") this.severity = "soft";
+      else if (this.severity === "soft") {
+        this.severity = "healthy";
+        this.healthySince = now2;
+      }
+      if (this.severity === "healthy") this.consecutive = 0;
+      if (prev !== this.severity) {
+        if (this.backoffMs > 0) {
+          this.backoffMs = 0;
+          this.log("backoff.clear", { reason: "severity-decay" });
+        }
+        this.log("severity", { severity: this.severity }, prev);
+      }
+    }
+    if (this.permitsMax !== null) {
+      const bootstrapCap = this.cfg.initialMaxConcurrency ?? 16;
+      if (this.severity !== "healthy") {
+        if (this.permitsMax < bootstrapCap) {
+          this.permitsMax = Math.min(bootstrapCap, this.permitsMax + this.cfg.recoveryStep);
+          if (this.permitsMax > this.cfg.floorConcurrency && this.backoffMs > 0) {
+            this.backoffMs = 0;
+            this.log("backoff.clear", { reason: "left-floor" });
+          }
+          this.log("permits.recover", { max: this.permitsMax, phase: "additive" }, this.severity);
+          this.release();
+        }
+      } else {
+        if (this.healthySince > 0 && now2 - this.healthySince >= this.cfg.unlimitedAfterHealthyMs) {
+          this.permitsMax = null;
+          this.permitsCurrent = 0;
+          this.backoffMs = 0;
+          while (this.waiters.length) {
+            const w = this.waiters.shift();
+            try {
+              w?.resolve();
+            } catch {
+            }
+          }
+          this.log("permits.unlimited", { reason: "sustained-healthy" }, this.severity);
+          return;
+        }
+        const next = Math.ceil(this.permitsMax * this.cfg.healthyRecoveryMultiplier);
+        if (next > this.permitsMax) {
+          this.permitsMax = next;
+          this.log(
+            "permits.recover",
+            { max: this.permitsMax, phase: "multiplicative" },
+            this.severity
+          );
+          this.release();
+        }
+      }
+    }
+  }
+};
+
+// src/runtime/jobActions.ts
+function enrichActivatedJob(raw, client2, log) {
+  let acknowledged = false;
+  const ack = () => {
+    if (!acknowledged) {
+      acknowledged = true;
+      job.acknowledged = true;
+    }
+  };
+  const job = { ...raw, log };
+  job.complete = async (variables = {}) => {
+    try {
+      await client2.completeJob({ variables, jobKey: raw.jobKey });
+    } finally {
+      ack();
+    }
+    return JobActionReceipt;
+  };
+  job.fail = async (reason) => {
+    try {
+      await client2.failJob({ ...reason, jobKey: raw.jobKey });
+    } finally {
+      ack();
+    }
+    return JobActionReceipt;
+  };
+  job.error = async (error) => {
+    try {
+      await client2.throwJobError({ ...error, jobKey: raw.jobKey });
+    } finally {
+      ack();
+    }
+    return JobActionReceipt;
+  };
+  job.cancelWorkflow = async () => {
+    try {
+      await client2.cancelProcessInstance({
+        processInstanceKey: raw.processInstanceKey
+      });
+    } finally {
+      ack();
+    }
+    return JobActionReceipt;
+  };
+  job.ignore = async () => {
+    ack();
+    return JobActionReceipt;
+  };
+  job.modifyJobTimeout = ({ newTimeoutMs }) => client2.updateJob({ changeset: { timeout: newTimeoutMs }, jobKey: raw.jobKey });
+  job.modifyRetries = ({ retries }) => client2.updateJob({ changeset: { retries }, jobKey: raw.jobKey });
+  return job;
+}
+
+// src/runtime/threadedJobWorker.ts
+var _workerCounter2 = 0;
+var DEFAULT_LONGPOLL_TIMEOUT2 = 0;
+var ThreadedJobWorker = class {
+  _client;
+  _pool;
+  _cfg;
+  _name;
+  _activeJobs = 0;
+  _stopped = false;
+  _pollTimer = null;
+  _inFlightActivation = null;
+  _log;
+  _jobQueue = [];
+  constructor(client2, pool, cfg) {
+    this._client = client2;
+    this._pool = pool;
+    this._cfg = { pollIntervalMs: 1, autoStart: true, validateSchemas: false, ...cfg };
+    this._name = cfg.workerName || `threaded-worker-${cfg.jobType}-${++_workerCounter2}`;
+    this._log = this._client.logger().scope(`worker:${this._name}`);
+    if (this._cfg.autoStart) this.start();
+  }
+  get name() {
+    return this._name;
+  }
+  get activeJobs() {
+    return this._activeJobs;
+  }
+  get stopped() {
+    return this._stopped;
+  }
+  /** Number of threads in the shared pool. */
+  get poolSize() {
+    return this._pool.size;
+  }
+  /** Number of threads currently processing a job (across all workers). */
+  get busyThreads() {
+    return this._pool.busyCount;
+  }
+  /** Resolves when the shared thread pool has finished initialising. */
+  get ready() {
+    return this._pool.ready;
+  }
+  start() {
+    if (this._stopped) return;
+    if (this._pollTimer) return;
+    this._log.info("worker.start");
+    const jitterMax = this._cfg.startupJitterMaxSeconds ?? 0;
+    if (jitterMax > 0) {
+      const jitterMs = Math.floor(Math.random() * jitterMax * 1e3);
+      this._log.info(() => ["worker.start.jitter", { delayMs: jitterMs }]);
+      this._scheduleNext(jitterMs);
+    } else {
+      this._scheduleNext(0);
+    }
+  }
+  stop() {
+    this._stopped = true;
+    if (this._pollTimer) clearTimeout(this._pollTimer);
+    this._pollTimer = null;
+    if (this._inFlightActivation?.cancel) {
+      try {
+        this._inFlightActivation.cancel();
+      } catch {
+      }
+    }
+    this._log.info("worker.stop");
+  }
+  async stopGracefully(opts) {
+    const waitUpToMs = opts?.waitUpToMs ?? 5e3;
+    const checkIntervalMs = opts?.checkIntervalMs ?? 10;
+    this._stopped = true;
+    if (this._pollTimer) clearTimeout(this._pollTimer);
+    this._pollTimer = null;
+    const start = Date.now();
+    if (this._inFlightActivation) {
+      try {
+        await Promise.race([
+          this._inFlightActivation,
+          new Promise(
+            (_, rej) => setTimeout(() => rej(new Error("activation.wait.timeout")), waitUpToMs)
+          )
+        ]);
+      } catch (e) {
+        if (e && e.message === "activation.wait.timeout") {
+          this._log.debug("worker.gracefulStop.activationTimeout");
+        }
+      }
+    }
+    while (this._activeJobs > 0 && Date.now() - start < waitUpToMs) {
+      await new Promise((r) => setTimeout(r, checkIntervalMs));
+    }
+    const timedOut = this._activeJobs > 0;
+    if (timedOut) {
+      if (this._inFlightActivation?.cancel) {
+        try {
+          this._inFlightActivation.cancel();
+        } catch {
+        }
+      }
+      this._log.debug("worker.gracefulStop.timeout", { remaining: this._activeJobs });
+    } else {
+      this._log.debug("worker.gracefulStop.done");
+    }
+    return { remainingJobs: this._activeJobs, timedOut };
+  }
+  // ─── Job dispatch ───
+  _drainQueue() {
+    while (this._jobQueue.length > 0) {
+      const idle = this._pool.getIdleWorker();
+      if (!idle) break;
+      const item = this._jobQueue.shift();
+      this._dispatchToThread(idle, item.raw);
+    }
+  }
+  async _dispatchToThread(pw, raw) {
+    const jobData = this._serializeJob(raw);
+    this._pool.dispatch(pw, jobData, this._cfg.handlerModule, {
+      onComplete: () => {
+        this._decrementOnce();
+        this._drainQueue();
+      },
+      onError: (err) => {
+        this._log.error("job.thread.error", { jobKey: raw.jobKey, err });
+        this._client.failJob({
+          jobKey: raw.jobKey,
+          errorMessage: err?.message || "Thread handler error",
+          retries: typeof raw.retries === "number" ? Math.max(0, raw.retries - 1) : 0
+        }).catch((failErr) => {
+          this._log.error("job.fail.error", failErr);
+        }).finally(() => {
+          this._decrementOnce();
+          this._drainQueue();
+        });
+      }
+    });
+  }
+  _serializeJob(raw) {
+    const data = {};
+    for (const [key, value] of Object.entries(raw)) {
+      if (typeof value === "function") continue;
+      if (key === "log") continue;
+      data[key] = value;
+    }
+    return JSON.parse(JSON.stringify(data));
+  }
+  // ─── Polling (same pattern as JobWorker) ───
+  _scheduleNext(delayMs) {
+    if (this._stopped) return;
+    this._pollTimer = setTimeout(() => this._poll(), delayMs);
+  }
+  async _poll() {
+    this._pollTimer = null;
+    if (this._stopped) return;
+    await this._pool.ready;
+    if (this._activeJobs >= this._cfg.maxParallelJobs) {
+      this._scheduleNext(this._cfg.pollIntervalMs);
+      return;
+    }
+    const availableThreads = this._pool.idleCount;
+    const batchSize = Math.min(this._cfg.maxParallelJobs - this._activeJobs, availableThreads);
+    if (batchSize <= 0) {
+      this._scheduleNext(this._cfg.pollIntervalMs);
+      return;
+    }
+    const body = {
+      type: this._cfg.jobType,
+      worker: this._name,
+      maxJobsToActivate: batchSize,
+      requestTimeout: this._cfg.pollTimeoutMs ?? DEFAULT_LONGPOLL_TIMEOUT2,
+      timeout: this._cfg.jobTimeoutMs,
+      ...this._cfg.fetchVariables && this._cfg.fetchVariables.length > 0 ? { fetchVariable: this._cfg.fetchVariables } : {}
+    };
+    this._log.debug(() => ["activation.request", { batchSize }]);
+    let result = [];
+    try {
+      this._inFlightActivation = this._client.activateJobs(body);
+      const activation = await this._inFlightActivation;
+      this._inFlightActivation = null;
+      result = activation?.jobs || [];
+      this._log.debug(() => ["activation.response", { jobs: result.length }]);
+    } catch (e) {
+      this._inFlightActivation = null;
+      if (this._stopped) return;
+      if (e?.name === "CancelSdkError") {
+        this._log.debug("activation.cancelled");
+      } else {
+        this._log.error("activation.error", e);
+      }
+      this._scheduleNext(this._cfg.pollIntervalMs);
+      return;
+    }
+    if (!result || result.length === 0) {
+      this._scheduleNext(this._cfg.pollIntervalMs);
+      return;
+    }
+    this._activeJobs += result.length;
+    this._scheduleNext(0);
+    for (const raw of result) {
+      this._handleJob(raw);
+    }
+  }
+  _handleJob(raw) {
+    if (this._stopped) {
+      this._decrementOnce();
+      return;
+    }
+    let variables = raw.variables;
+    let headers = raw.customHeaders;
+    if (this._cfg.validateSchemas) {
+      if (this._cfg.inputSchema) {
+        const parsed = this._cfg.inputSchema.safeParse(variables);
+        if (!parsed.success) {
+          this._log.warn("job.validation.variables.failed", parsed.error.flatten());
+          this._failValidation(raw, "Invalid variables");
+          return;
+        }
+        variables = parsed.data;
+      }
+      if (this._cfg.customHeadersSchema) {
+        const parsed = this._cfg.customHeadersSchema.safeParse(headers);
+        if (!parsed.success) {
+          this._log.warn("job.validation.headers.failed", parsed.error.flatten());
+          this._failValidation(raw, "Invalid custom headers");
+          return;
+        }
+        headers = parsed.data;
+      }
     }
-    if (this.severity !== prevSeverity)
-      this.log("severity", { severity: this.severity }, prevSeverity);
-  }
-  recordHealthyHint() {
-    if (!this.cfg.enabled && !this.observeOnly) return;
-    if (this.backoffMs > 0) {
-      this.backoffMs = 0;
-      this.log("backoff.clear", { reason: "healthy-hint" });
+    const enriched = Object.assign(raw, { variables, customHeaders: headers });
+    const idle = this._pool.getIdleWorker();
+    if (idle) {
+      this._dispatchToThread(idle, enriched);
+    } else {
+      this._jobQueue.push({ raw: enriched });
     }
-    const now2 = this.now();
-    this.maybeRecover(now2);
   }
-  scalePermits(factor) {
-    if (this.permitsMax === null) return;
-    const next = Math.max(this.cfg.floorConcurrency, Math.ceil(this.permitsMax * factor));
-    if (next < this.permitsMax) {
-      this.permitsMax = next;
-      this.log("permits.scale", { max: this.permitsMax });
+  async _failValidation(raw, msg) {
+    try {
+      await this._client.failJob({ jobKey: raw.jobKey, errorMessage: msg });
+    } catch (e) {
+      this._log.error("job.fail.validation.error", e);
+    } finally {
+      this._decrementOnce();
     }
   }
-  maybeRecover(now2 = this.now()) {
-    if (this.permitsMax === null || this.observeOnly) return;
-    if (now2 - this.lastRecoverCheck < this.cfg.recoveryIntervalMs) return;
-    this.lastRecoverCheck = now2;
-    if (now2 - this.lastEventAt > this.cfg.decayQuietMs) {
-      const prev = this.severity;
-      if (this.severity === "severe") this.severity = "soft";
-      else if (this.severity === "soft") {
-        this.severity = "healthy";
-        this.healthySince = now2;
+  _decrementOnce() {
+    this._activeJobs = Math.max(0, this._activeJobs - 1);
+  }
+};
+
+// src/runtime/clientProxy.ts
+function installClientCallHandler(port, client2) {
+  port.on("message", async (msg) => {
+    if (msg.type !== "client-call") return;
+    try {
+      const fn = client2[msg.method];
+      if (typeof fn !== "function") {
+        throw new Error(`CamundaClient has no method '${msg.method}'`);
       }
-      if (this.severity === "healthy") this.consecutive = 0;
-      if (prev !== this.severity) {
-        if (this.backoffMs > 0) {
-          this.backoffMs = 0;
-          this.log("backoff.clear", { reason: "severity-decay" });
-        }
-        this.log("severity", { severity: this.severity }, prev);
+      const result = await fn.apply(client2, msg.args);
+      const reply = { type: "client-call-result", callId: msg.callId, result };
+      port.postMessage(reply);
+    } catch (err) {
+      const reply = {
+        type: "client-call-result",
+        callId: msg.callId,
+        error: err?.message || String(err)
+      };
+      port.postMessage(reply);
+    }
+  });
+}
+
+// src/runtime/threadPool.ts
+var ThreadPool = class {
+  _pool = [];
+  _pending = /* @__PURE__ */ new Map();
+  _node;
+  _log;
+  _client;
+  _ready;
+  _terminated = false;
+  constructor(client2, size) {
+    this._client = client2;
+    this._log = client2.logger().scope("thread-pool");
+    this._ready = this._init(size);
+  }
+  /** Resolves when all threads have been spawned and signalled ready. */
+  get ready() {
+    return this._ready;
+  }
+  /** Total number of threads in the pool. */
+  get size() {
+    return this._pool.length;
+  }
+  /** Number of threads currently processing a job. */
+  get busyCount() {
+    return this._pool.filter((pw) => pw.busy).length;
+  }
+  /** Number of threads that are ready and idle. */
+  get idleCount() {
+    return this._pool.filter((pw) => pw.ready && !pw.busy).length;
+  }
+  /** Find the first ready & idle thread. */
+  getIdleWorker() {
+    return this._pool.find((pw) => pw.ready && !pw.busy);
+  }
+  /**
+   * Dispatch a serialized job to a specific idle worker.
+   * The caller is responsible for checking idleness first.
+   */
+  async dispatch(pw, jobData, handlerModule, callbacks) {
+    const { randomUUID, MessageChannel } = this._node;
+    const taskId = randomUUID();
+    pw.busy = true;
+    pw.currentTaskId = taskId;
+    const { port1: mainPort, port2: workerPort } = new MessageChannel();
+    installClientCallHandler(mainPort, this._client);
+    this._pending.set(taskId, {
+      resolve: () => {
+        this._pending.delete(taskId);
+        mainPort.close();
+        callbacks.onComplete();
+      },
+      reject: (err) => {
+        this._pending.delete(taskId);
+        mainPort.close();
+        callbacks.onError(err);
       }
+    });
+    pw.worker.postMessage({ type: "job", taskId, jobData, handlerModule, clientPort: workerPort }, [
+      workerPort
+    ]);
+  }
+  /** Terminate all threads and reject any in-flight tasks. */
+  terminate() {
+    this._terminated = true;
+    for (const pw of this._pool) {
+      pw.worker.terminate().catch(() => {
+      });
     }
-    if (this.permitsMax !== null) {
-      const bootstrapCap = this.cfg.initialMaxConcurrency ?? 16;
-      if (this.severity !== "healthy") {
-        if (this.permitsMax < bootstrapCap) {
-          this.permitsMax = Math.min(bootstrapCap, this.permitsMax + this.cfg.recoveryStep);
-          if (this.permitsMax > this.cfg.floorConcurrency && this.backoffMs > 0) {
-            this.backoffMs = 0;
-            this.log("backoff.clear", { reason: "left-floor" });
-          }
-          this.log("permits.recover", { max: this.permitsMax, phase: "additive" }, this.severity);
-          this.release();
+    this._pool = [];
+    for (const [, pending] of this._pending) {
+      pending.reject(new Error("Thread pool terminated"));
+    }
+    this._pending.clear();
+  }
+  /** Reject the pending task for a worker that errored/exited and reset its state. */
+  _rejectWorkerTask(pw, message) {
+    pw.busy = false;
+    if (pw.currentTaskId) {
+      const pending = this._pending.get(pw.currentTaskId);
+      if (pending) {
+        this._pending.delete(pw.currentTaskId);
+        pending.reject(new Error(message));
+      }
+      pw.currentTaskId = void 0;
+    }
+  }
+  async _init(requestedSize) {
+    const [workerThreads, pathMod, crypto] = await Promise.all([
+      import("worker_threads"),
+      import("path"),
+      import("crypto")
+    ]);
+    const { Worker } = workerThreads;
+    const { join } = pathMod;
+    this._node = {
+      MessageChannel: workerThreads.MessageChannel,
+      randomUUID: crypto.randomUUID
+    };
+    const cpus = await (async () => {
+      try {
+        const os = await import("os");
+        return os.availableParallelism?.() || os.cpus().length;
+      } catch {
+        return 4;
+      }
+    })();
+    const size = requestedSize ?? cpus;
+    const fs = await import("fs");
+    const url = await import("url");
+    const dir = typeof __dirname !== "undefined" ? __dirname : pathMod.dirname(url.fileURLToPath(import.meta.url));
+    const jsPath = join(dir, "threadWorkerEntry.js");
+    const tsPath = join(dir, "threadWorkerEntry.ts");
+    const entryPath = fs.existsSync(jsPath) ? jsPath : tsPath;
+    const nodeMajor = parseInt(process.versions.node, 10);
+    const execArgv = entryPath.endsWith(".ts") || nodeMajor >= 22 ? ["--experimental-strip-types", "--experimental-transform-types"] : [];
+    for (let i = 0; i < size; i++) {
+      const worker = new Worker(entryPath, { execArgv });
+      const pw = { worker, busy: false, ready: false };
+      worker.on("message", (msg) => {
+        if (msg.type === "ready") {
+          pw.ready = true;
+          this._log.debug(() => ["thread.ready", { index: i }]);
+          return;
         }
-      } else {
-        if (this.healthySince > 0 && now2 - this.healthySince >= this.cfg.unlimitedAfterHealthyMs) {
-          this.permitsMax = null;
-          this.permitsCurrent = 0;
-          this.backoffMs = 0;
-          while (this.waiters.length) {
-            const w = this.waiters.shift();
-            try {
-              w?.resolve();
-            } catch {
+        if (msg.type === "job-result") {
+          this._log.debug(() => [
+            "thread.job-result",
+            { taskId: msg.taskId, ok: msg.ok, error: msg.error }
+          ]);
+          pw.busy = false;
+          pw.currentTaskId = void 0;
+          const pending = this._pending.get(msg.taskId);
+          if (pending) {
+            if (msg.ok) {
+              pending.resolve(true);
+            } else {
+              pending.reject(new Error(msg.error || "Handler failed"));
             }
           }
-          this.log("permits.unlimited", { reason: "sustained-healthy" }, this.severity);
           return;
         }
-        const next = Math.ceil(this.permitsMax * this.cfg.healthyRecoveryMultiplier);
-        if (next > this.permitsMax) {
-          this.permitsMax = next;
-          this.log(
-            "permits.recover",
-            { max: this.permitsMax, phase: "multiplicative" },
-            this.severity
-          );
-          this.release();
+      });
+      worker.on("error", (err) => {
+        this._log.error("thread.error", err);
+        this._rejectWorkerTask(pw, `Worker thread error: ${err.message}`);
+        pw.ready = false;
+      });
+      worker.on("exit", (code) => {
+        if (!this._terminated) {
+          this._log.warn("thread.exit", { code });
+          this._rejectWorkerTask(pw, `Worker thread exited unexpectedly (code ${code})`);
         }
-      }
+      });
+      this._pool.push(pw);
     }
+    this._log.info(() => ["thread-pool.init", { size, entryPath }]);
   }
 };
 
-// src/runtime/jobActions.ts
-function enrichActivatedJob(raw, client2, log) {
-  let acknowledged = false;
-  const ack = () => {
-    if (!acknowledged) {
-      acknowledged = true;
-      job.acknowledged = true;
-    }
-  };
-  const job = { ...raw, log };
-  job.complete = async (variables = {}) => {
-    try {
-      await client2.completeJob({ variables, jobKey: raw.jobKey });
-    } finally {
-      ack();
-    }
-    return JobActionReceipt;
-  };
-  job.fail = async (reason) => {
-    try {
-      await client2.failJob({ ...reason, jobKey: raw.jobKey });
-    } finally {
-      ack();
-    }
-    return JobActionReceipt;
-  };
-  job.error = async (error) => {
-    try {
-      await client2.throwJobError({ ...error, jobKey: raw.jobKey });
-    } finally {
-      ack();
-    }
-    return JobActionReceipt;
-  };
-  job.cancelWorkflow = async () => {
-    try {
-      await client2.cancelProcessInstance({
-        processInstanceKey: raw.processInstanceKey
-      });
-    } finally {
-      ack();
-    }
-    return JobActionReceipt;
-  };
-  job.ignore = async () => {
-    ack();
-    return JobActionReceipt;
-  };
-  job.modifyJobTimeout = ({ newTimeoutMs }) => client2.updateJob({ changeset: { timeout: newTimeoutMs }, jobKey: raw.jobKey });
-  job.modifyRetries = ({ retries }) => client2.updateJob({ changeset: { retries }, jobKey: raw.jobKey });
-  return job;
-}
-
 // src/runtime/responseEvaluation.ts
 function evaluateSdkResponse(raw, opts) {
   if (!raw || typeof raw !== "object") return raw;
@@ -13603,6 +14168,8 @@ var CamundaClient = class {
   _bp;
   /** Registered job workers created via createJobWorker (lifecycle managed by user). */
   _workers = [];
+  /** Shared thread pool for all threaded job workers (lazy-initialised on first use). */
+  _threadPool = null;
   /** Support logger (Node-only; no-op in browser). */
   _supportLogger = new class {
     log() {
@@ -13898,7 +14465,7 @@ var CamundaClient = class {
   getWorkers() {
     return [...this._workers];
   }
-  /** Stop all registered job workers (best-effort). */
+  /** Stop all registered job workers (best-effort) and terminate the shared thread pool. */
   stopAllWorkers() {
     for (const w of this._workers) {
       try {
@@ -13907,6 +14474,17 @@ var CamundaClient = class {
         this._log.warn("worker.stop.error", e);
       }
     }
+    if (this._threadPool) {
+      this._threadPool.terminate();
+      this._threadPool = null;
+    }
+  }
+  /** Get or lazily create the shared thread pool for threaded job workers. */
+  _getOrCreateThreadPool(threadPoolSize) {
+    if (!this._threadPool) {
+      this._threadPool = new ThreadPool(this, threadPoolSize);
+    }
+    return this._threadPool;
   }
   activateAdHocSubProcessActivities(arg, options) {
     return toCancelable2(async (signal) => {
@@ -15917,9 +16495,9 @@ var CamundaClient = class {
   }
   deleteDecisionInstance(arg, options) {
     return toCancelable2(async (signal) => {
-      const { decisionInstanceKey, ..._body } = arg || {};
+      const { decisionEvaluationKey, ..._body } = arg || {};
       let envelope = {};
-      envelope.path = { decisionInstanceKey };
+      envelope.path = { decisionEvaluationKey };
       envelope.body = _body;
       if (this._validation.settings.req !== "none") {
         const maybe = await this._validation.gateRequest("deleteDecisionInstance", zDeleteDecisionInstanceData, envelope);
@@ -17687,6 +18265,60 @@ var CamundaClient = class {
       return invoke();
     });
   }
+  getJobErrorStatistics(arg, consistencyManagement, options) {
+    if (!consistencyManagement) throw new Error("Missing consistencyManagement parameter for eventually consistent endpoint");
+    const useConsistency = consistencyManagement.consistency;
+    return toCancelable2(async (signal) => {
+      const _body = arg;
+      let envelope = {};
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const maybe = await this._validation.gateRequest("getJobErrorStatistics", zGetJobErrorStatisticsData, 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 getJobErrorStatistics(opts);
+          let data = this._evaluateResponse(_raw, "getJobErrorStatistics", (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 = "zGetJobErrorStatisticsResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schema = zGetJobErrorStatisticsResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("getJobErrorStatistics", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      const invoke = () => toCancelable2(() => call());
+      if (useConsistency) return eventualPoll("getJobErrorStatistics", false, invoke, { ...useConsistency, logger: this._log });
+      return invoke();
+    });
+  }
   getJobTimeSeriesStatistics(arg, consistencyManagement, options) {
     if (!consistencyManagement) throw new Error("Missing consistencyManagement parameter for eventually consistent endpoint");
     const useConsistency = consistencyManagement.consistency;
@@ -18845,6 +19477,48 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "getStatus", exempt: false, retryOverride: options?.retry });
     });
   }
+  getSystemConfiguration(arg, options) {
+    return toCancelable2(async (signal) => {
+      const opts = { client: this._client, signal, throwOnError: false };
+      const call = async () => {
+        try {
+          const _raw = await getSystemConfiguration(opts);
+          let data = this._evaluateResponse(_raw, "getSystemConfiguration", (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 = "zGetSystemConfigurationResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schema = zGetSystemConfigurationResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("getSystemConfiguration", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "getSystemConfiguration", exempt: false, retryOverride: options?.retry });
+    });
+  }
   getTenant(arg, consistencyManagement, options) {
     if (!consistencyManagement) throw new Error("Missing consistencyManagement parameter for eventually consistent endpoint");
     const useConsistency = consistencyManagement.consistency;
@@ -23359,6 +24033,31 @@ var CamundaClient = class {
     this._workers.push(worker);
     return worker;
   }
+  /**
+   * Create a threaded job worker that runs handler logic in a pool of worker threads.
+   * The handler must be a separate module file that exports a default function with
+   * signature `(job, client) => Promise<JobActionReceipt>`.
+   *
+   * This keeps the main event loop free for polling and I/O, dramatically improving
+   * throughput for CPU-bound job handlers.
+   *
+   * @param cfg Threaded worker configuration
+   * @example Create a threaded job worker
+   * ```ts
+   * const worker = client.createThreadedJobWorker({
+   *   jobType: 'cpu-heavy-task',
+   *   handlerModule: './my-handler.js',
+   *   maxParallelJobs: 32,
+   *   jobTimeoutMs: 30000,
+   * })
+   * ```
+   */
+  createThreadedJobWorker(cfg) {
+    const pool = this._getOrCreateThreadPool(cfg.threadPoolSize);
+    const worker = new ThreadedJobWorker(this, pool, cfg);
+    this._workers.push(worker);
+    return worker;
+  }
   /**
    * Node-only convenience: deploy resources from local filesystem paths.
    * @param resourceFilenames Absolute or relative file paths to BPMN/DMN/form/resource files.
@@ -23550,4 +24249,4 @@ export {
   withTimeoutTE,
   eventuallyTE
 };
-//# sourceMappingURL=chunk-ULXL7H75.js.map
+//# sourceMappingURL=chunk-G5VLLLLV.js.map