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

package/dist/index.cjs

@@ -1256,7 +1256,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",
@@ -1811,6 +1811,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,
@@ -2407,6 +2419,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,
@@ -3104,6 +3124,7 @@ __export(zod_gen_exports, {
   zEvaluatedDecisionResult: () => zEvaluatedDecisionResult,
   zExpressionEvaluationRequest: () => zExpressionEvaluationRequest,
   zExpressionEvaluationResult: () => zExpressionEvaluationResult,
+  zExpressionEvaluationWarningItem: () => zExpressionEvaluationWarningItem,
   zFailJobData: () => zFailJobData,
   zFailJobResponse: () => zFailJobResponse,
   zFormId: () => zFormId,
@@ -3143,6 +3164,8 @@ __export(zod_gen_exports, {
   zGetGroupResponse: () => zGetGroupResponse,
   zGetIncidentData: () => zGetIncidentData,
   zGetIncidentResponse: () => zGetIncidentResponse,
+  zGetJobErrorStatisticsData: () => zGetJobErrorStatisticsData,
+  zGetJobErrorStatisticsResponse: () => zGetJobErrorStatisticsResponse,
   zGetJobTimeSeriesStatisticsData: () => zGetJobTimeSeriesStatisticsData,
   zGetJobTimeSeriesStatisticsResponse: () => zGetJobTimeSeriesStatisticsResponse,
   zGetJobTypeStatisticsData: () => zGetJobTypeStatisticsData,
@@ -3187,6 +3210,8 @@ __export(zod_gen_exports, {
   zGetStartProcessFormResponse: () => zGetStartProcessFormResponse,
   zGetStatusData: () => zGetStatusData,
   zGetStatusResponse: () => zGetStatusResponse,
+  zGetSystemConfigurationData: () => zGetSystemConfigurationData,
+  zGetSystemConfigurationResponse: () => zGetSystemConfigurationResponse,
   zGetTenantClusterVariableData: () => zGetTenantClusterVariableData,
   zGetTenantClusterVariableResponse: () => zGetTenantClusterVariableResponse,
   zGetTenantData: () => zGetTenantData,
@@ -3267,6 +3292,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,
@@ -3278,6 +3307,7 @@ __export(zod_gen_exports, {
   zJobListenerEventTypeEnum: () => zJobListenerEventTypeEnum,
   zJobListenerEventTypeExactMatch: () => zJobListenerEventTypeExactMatch,
   zJobListenerEventTypeFilterProperty: () => zJobListenerEventTypeFilterProperty,
+  zJobMetricsConfigurationResponse: () => zJobMetricsConfigurationResponse,
   zJobResult: () => zJobResult,
   zJobResultActivateElement: () => zJobResultActivateElement,
   zJobResultAdHocSubProcess: () => zJobResultAdHocSubProcess,
@@ -3556,6 +3586,7 @@ __export(zod_gen_exports, {
   zStringFilterProperty: () => zStringFilterProperty,
   zSuspendBatchOperationData: () => zSuspendBatchOperationData,
   zSuspendBatchOperationResponse: () => zSuspendBatchOperationResponse,
+  zSystemConfigurationResponse: () => zSystemConfigurationResponse,
   zTag: () => zTag,
   zTagSet: () => zTagSet,
   zTenantClientResult: () => zTenantClientResult,
@@ -3881,18 +3912,18 @@ var zAuthorizationFilter = import_zod.z.object({
   description: "Authorization search filter."
 });
 var zBatchOperationError = import_zod.z.object({
-  partitionId: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  partitionId: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The partition ID where the error occurred."
-  })),
-  type: import_zod.z.optional(import_zod.z.enum([
+  }),
+  type: import_zod.z.enum([
     "QUERY_FAILED",
     "RESULT_BUFFER_SIZE_EXCEEDED"
   ]).register(import_zod.z.globalRegistry, {
     description: "The type of the error that occurred during the batch operation."
-  })),
-  message: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  message: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The error message that occurred during the batch operation."
-  }))
+  })
 });
 var zBatchOperationItemStateEnum = import_zod.z.enum([
   "ACTIVE",
@@ -4022,10 +4053,10 @@ var zTopologyResponse = import_zod.z.object({
   brokers: import_zod.z.array(zBrokerInfo).register(import_zod.z.globalRegistry, {
     description: "A list of brokers that are part of this cluster."
   }),
-  clusterId: import_zod.z.optional(import_zod.z.union([
+  clusterId: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
+  ]),
   clusterSize: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The number of brokers in the cluster."
   }),
@@ -4051,28 +4082,28 @@ var zEndCursor = import_zod.z.string().regex(/^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0
   description: "The end cursor in a search query result set."
 });
 var zEvaluatedDecisionInputItem = import_zod.z.object({
-  inputId: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  inputId: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The identifier of the decision input."
-  })),
-  inputName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  inputName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the decision input."
-  })),
-  inputValue: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
-    description: "The description of the decision input."
-  }))
+  }),
+  inputValue: import_zod.z.string().register(import_zod.z.globalRegistry, {
+    description: "The value of the decision input."
+  })
 }).register(import_zod.z.globalRegistry, {
   description: "A decision input that was evaluated within this decision evaluation."
 });
 var zEvaluatedDecisionOutputItem = import_zod.z.object({
-  outputId: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  outputId: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The ID of the evaluated decison output item."
-  })),
-  outputName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  outputName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the of the evaluated decison output item."
-  })),
-  outputValue: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  outputValue: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The value of the evaluated decison output item."
-  })),
+  }),
   ruleId: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
@@ -4085,12 +4116,12 @@ var zEvaluatedDecisionOutputItem = import_zod.z.object({
   description: "The evaluated decision outputs."
 });
 var zMatchedDecisionRuleItem = import_zod.z.object({
-  ruleId: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  ruleId: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The ID of the matched rule."
-  })),
-  ruleIndex: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  }),
+  ruleIndex: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The index of the matched rule."
-  })),
+  }),
   evaluatedOutputs: import_zod.z.array(zEvaluatedDecisionOutputItem).register(import_zod.z.globalRegistry, {
     description: "The evaluated decision outputs."
   })
@@ -4114,18 +4145,18 @@ var zDecisionInstanceStateEnum = import_zod.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 = import_zod.z.object({
-  fileName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  fileName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the file that failed to upload."
-  })),
-  status: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  }),
+  status: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The HTTP status code of the failure."
-  })),
-  title: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  title: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "A short, human-readable summary of the problem type."
-  })),
-  detail: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  detail: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "A human-readable explanation specific to this occurrence of the problem."
-  }))
+  })
 });
 var zDocumentLinkRequest = import_zod.z.object({
   timeToLive: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
@@ -4162,6 +4193,11 @@ var zExpressionEvaluationRequest = import_zod.z.object({
     import_zod.z.null()
   ]))
 });
+var zExpressionEvaluationWarningItem = import_zod.z.object({
+  message: import_zod.z.string().register(import_zod.z.globalRegistry, {
+    description: "The warning message"
+  })
+});
 var zExpressionEvaluationResult = import_zod.z.object({
   expression: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The evaluated expression"
@@ -4169,7 +4205,7 @@ var zExpressionEvaluationResult = import_zod.z.object({
   result: import_zod.z.unknown().register(import_zod.z.globalRegistry, {
     description: "The result value. Its type can vary."
   }),
-  warnings: import_zod.z.array(import_zod.z.string()).register(import_zod.z.globalRegistry, {
+  warnings: import_zod.z.array(zExpressionEvaluationWarningItem).register(import_zod.z.globalRegistry, {
     description: "List of warnings generated during expression evaluation"
   })
 });
@@ -4557,7 +4593,7 @@ var zGroupClientResult = import_zod.z.object({
     description: "The ID of the client."
   })
 });
-var zProcessDefinitionId = import_zod.z.string().min(1).regex(/^[a-zA-Z_][a-zA-Z0-9_\-\.]*$/).register(import_zod.z.globalRegistry, {
+var zProcessDefinitionId = import_zod.z.string().min(1).regex(/^[\p{L}_][\p{L}\p{N}_\-\.]*$/u).register(import_zod.z.globalRegistry, {
   description: "Id of a process definition, from the model. Only ids of process definitions that are deployed are useful."
 });
 var zElementId = import_zod.z.string().register(import_zod.z.globalRegistry, {
@@ -4586,7 +4622,7 @@ var zAdHocSubProcessActivateActivitiesInstruction = import_zod.z.object({
 var zFormId = import_zod.z.string().register(import_zod.z.globalRegistry, {
   description: "The user-defined id for the form"
 });
-var zDecisionDefinitionId = import_zod.z.string().min(1).max(256).regex(/^[A-Za-z0-9_@.+-]+$/).register(import_zod.z.globalRegistry, {
+var zDecisionDefinitionId = import_zod.z.string().min(1).regex(/^[\p{L}_][\p{L}\p{N}_\-\.]*$/u).register(import_zod.z.globalRegistry, {
   description: "Id of a decision definition, from the model. Only ids of decision definitions that are deployed are useful."
 });
 var zGlobalListenerId = import_zod.z.string().register(import_zod.z.globalRegistry, {
@@ -4688,15 +4724,15 @@ var zAdvancedIncidentStateFilter = import_zod.z.object({
   description: "Advanced IncidentStateEnum filter"
 });
 var zIncidentProcessInstanceStatisticsByErrorResult = import_zod.z.object({
-  errorHashCode: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  errorHashCode: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The hash code identifying a specific incident error.."
-  })),
-  errorMessage: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  errorMessage: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The error message associated with the incident error hash code."
-  })),
-  activeInstancesWithErrorCount: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  }),
+  activeInstancesWithErrorCount: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "The number of active process instances that currently have an active incident with this error.\n"
-  }))
+  })
 });
 var zIncidentProcessInstanceStatisticsByDefinitionFilter = import_zod.z.object({
   errorHashCode: import_zod.z.int().register(import_zod.z.globalRegistry, {
@@ -4765,7 +4801,7 @@ var zJobWorkerStatisticsFilter = import_zod.z.object({
 });
 var zJobWorkerStatisticsItem = import_zod.z.object({
   worker: import_zod.z.string().register(import_zod.z.globalRegistry, {
-    description: "The worker identifier."
+    description: "The name of the worker activating the jobs, mostly used for logging purposes."
   }),
   created: zStatusMetric,
   completed: zStatusMetric,
@@ -4799,6 +4835,34 @@ var zJobTimeSeriesStatisticsItem = import_zod.z.object({
 }).register(import_zod.z.globalRegistry, {
   description: "Aggregated job metrics for a single time bucket."
 });
+var zJobErrorStatisticsFilter = import_zod.z.object({
+  from: import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
+    description: "Start of the time window to filter metrics. ISO 8601 date-time format.\n"
+  }),
+  to: import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
+    description: "End of the time window to filter metrics. ISO 8601 date-time format.\n"
+  }),
+  jobType: import_zod.z.string().register(import_zod.z.globalRegistry, {
+    description: "Job type to return error metrics for."
+  }),
+  errorCode: import_zod.z.optional(zStringFilterProperty),
+  errorMessage: import_zod.z.optional(zStringFilterProperty)
+}).register(import_zod.z.globalRegistry, {
+  description: "Job error statistics search filter."
+});
+var zJobErrorStatisticsItem = import_zod.z.object({
+  errorCode: import_zod.z.string().register(import_zod.z.globalRegistry, {
+    description: "The error code identifier."
+  }),
+  errorMessage: import_zod.z.string().register(import_zod.z.globalRegistry, {
+    description: "The error message."
+  }),
+  workers: import_zod.z.int().register(import_zod.z.globalRegistry, {
+    description: "Number of distinct workers that encountered this error."
+  })
+}).register(import_zod.z.globalRegistry, {
+  description: "Aggregated error metrics for a single error type and message combination."
+});
 var zJobFailRequest = import_zod.z.object({
   retries: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The amount of retries the job should have left"
@@ -5152,8 +5216,8 @@ var zConditionalEvaluationInstruction = import_zod.z.object({
   })
 });
 var zProcessInstanceReference = import_zod.z.object({
-  processDefinitionKey: import_zod.z.optional(zProcessDefinitionKey),
-  processInstanceKey: import_zod.z.optional(zProcessInstanceKey)
+  processDefinitionKey: zProcessDefinitionKey,
+  processInstanceKey: zProcessInstanceKey
 });
 var zEvaluateConditionalResult = import_zod.z.object({
   conditionalEvaluationKey: zConditionalEvaluationKey,
@@ -5176,32 +5240,32 @@ var zDeploymentProcessResult = import_zod.z.object({
   description: "A deployed process."
 });
 var zIncidentProcessInstanceStatisticsByDefinitionResult = import_zod.z.object({
-  processDefinitionId: import_zod.z.optional(zProcessDefinitionId),
-  processDefinitionKey: import_zod.z.optional(zProcessDefinitionKey),
-  processDefinitionName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  processDefinitionId: zProcessDefinitionId,
+  processDefinitionKey: zProcessDefinitionKey,
+  processDefinitionName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the process definition."
-  })),
-  processDefinitionVersion: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  }),
+  processDefinitionVersion: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The version of the process definition."
-  })),
-  tenantId: import_zod.z.optional(zTenantId),
-  activeInstancesWithErrorCount: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  }),
+  tenantId: zTenantId,
+  activeInstancesWithErrorCount: import_zod.z.coerce.bigint().register(import_zod.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 = import_zod.z.object({
-  formId: import_zod.z.optional(zFormId),
-  version: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  formId: zFormId,
+  version: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The version of the deployed form."
-  })),
-  resourceName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  resourceName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the resource."
-  })),
-  tenantId: import_zod.z.optional(zTenantId),
-  formKey: import_zod.z.optional(zFormKey)
+  }),
+  tenantId: zTenantId,
+  formKey: zFormKey
 }).register(import_zod.z.globalRegistry, {
   description: "A deployed form."
 });
@@ -5217,13 +5281,13 @@ var zFormResult = import_zod.z.object({
   formKey: zFormKey
 });
 var zUserTaskProperties = import_zod.z.object({
-  action: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  action: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The action performed on the user task."
-  })),
-  assignee: import_zod.z.optional(import_zod.z.union([
+  }),
+  assignee: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
+  ]),
   candidateGroups: import_zod.z.array(import_zod.z.string()).register(import_zod.z.globalRegistry, {
     description: "The groups eligible to claim the task."
   }),
@@ -5233,23 +5297,26 @@ var zUserTaskProperties = import_zod.z.object({
   changedAttributes: import_zod.z.array(import_zod.z.string()).register(import_zod.z.globalRegistry, {
     description: "The attributes that were changed in the task."
   }),
-  dueDate: import_zod.z.optional(import_zod.z.union([
+  dueDate: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
-  followUpDate: import_zod.z.optional(import_zod.z.union([
+  ]),
+  followUpDate: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
-  formKey: import_zod.z.optional(zFormKey),
-  priority: import_zod.z.optional(import_zod.z.union([
+  ]),
+  formKey: import_zod.z.union([
+    zFormKey,
+    import_zod.z.null()
+  ]),
+  priority: import_zod.z.union([
     import_zod.z.int().gte(0).lte(100),
     import_zod.z.null()
-  ])),
-  userTaskKey: import_zod.z.optional(import_zod.z.union([
+  ]),
+  userTaskKey: import_zod.z.union([
     zUserTaskKey,
     import_zod.z.null()
-  ]))
+  ])
 }).register(import_zod.z.globalRegistry, {
   description: "Contains properties of a user task."
 });
@@ -5261,10 +5328,10 @@ var zElementInstanceResult = import_zod.z.object({
   startDate: import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
     description: "Date when element instance started."
   }),
-  endDate: import_zod.z.optional(import_zod.z.union([
+  endDate: import_zod.z.union([
     import_zod.z.iso.datetime(),
     import_zod.z.null()
-  ])),
+  ]),
   elementId: zElementId,
   elementName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The element name for this element instance."
@@ -5312,10 +5379,10 @@ var zElementInstanceResult = import_zod.z.object({
     import_zod.z.null()
   ]),
   processDefinitionKey: zProcessDefinitionKey,
-  incidentKey: import_zod.z.optional(import_zod.z.union([
+  incidentKey: import_zod.z.union([
     zIncidentKey,
     import_zod.z.null()
-  ]))
+  ])
 });
 var zJobKey = zLongKey;
 var zIncidentResult = import_zod.z.object({
@@ -5374,10 +5441,10 @@ var zActivatedJobResult = import_zod.z.object({
   elementInstanceKey: zElementInstanceKey,
   kind: zJobKindEnum,
   listenerEventType: zJobListenerEventTypeEnum,
-  userTask: import_zod.z.optional(import_zod.z.union([
+  userTask: import_zod.z.union([
     zUserTaskProperties,
     import_zod.z.null()
-  ])),
+  ]),
   tags: zTagSet,
   rootProcessInstanceKey: import_zod.z.union([
     zProcessInstanceKey,
@@ -5395,38 +5462,38 @@ var zJobSearchResult = import_zod.z.object({
   customHeaders: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).register(import_zod.z.globalRegistry, {
     description: "A set of custom headers defined during modelling."
   }),
-  deadline: import_zod.z.optional(import_zod.z.union([
+  deadline: import_zod.z.union([
     import_zod.z.iso.datetime(),
     import_zod.z.null()
-  ])),
-  deniedReason: import_zod.z.optional(import_zod.z.union([
+  ]),
+  deniedReason: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
+  ]),
   elementId: import_zod.z.union([
     zElementId,
     import_zod.z.null()
   ]),
   elementInstanceKey: zElementInstanceKey,
-  endTime: import_zod.z.optional(import_zod.z.union([
+  endTime: import_zod.z.union([
     import_zod.z.iso.datetime(),
     import_zod.z.null()
-  ])),
-  errorCode: import_zod.z.optional(import_zod.z.union([
+  ]),
+  errorCode: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
-  errorMessage: import_zod.z.optional(import_zod.z.union([
+  ]),
+  errorMessage: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
+  ]),
   hasFailedWithRetriesLeft: import_zod.z.boolean().register(import_zod.z.globalRegistry, {
     description: "Indicates whether the job has failed with retries left."
   }),
-  isDenied: import_zod.z.optional(import_zod.z.union([
+  isDenied: import_zod.z.union([
     import_zod.z.boolean(),
     import_zod.z.null()
-  ])),
+  ]),
   jobKey: zJobKey,
   kind: zJobKindEnum,
   listenerEventType: zJobListenerEventTypeEnum,
@@ -5448,12 +5515,14 @@ var zJobSearchResult = import_zod.z.object({
   worker: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the worker of this job."
   }),
-  creationTime: import_zod.z.optional(import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
-    description: "When the job was created. Field is present for jobs created after 8.9."
-  })),
-  lastUpdateTime: import_zod.z.optional(import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
-    description: "When the job was last updated. Field is present for jobs created after 8.9."
-  }))
+  creationTime: import_zod.z.union([
+    import_zod.z.iso.datetime(),
+    import_zod.z.null()
+  ]),
+  lastUpdateTime: import_zod.z.union([
+    import_zod.z.iso.datetime(),
+    import_zod.z.null()
+  ])
 });
 var zDecisionDefinitionKey = zLongKey;
 var zDecisionEvaluationByKey = import_zod.z.object({
@@ -5469,28 +5538,28 @@ var zDecisionEvaluationInstruction = import_zod.z.union([
 ]);
 var zDecisionEvaluationInstanceKey = zLongKey;
 var zEvaluatedDecisionResult = import_zod.z.object({
-  decisionDefinitionId: import_zod.z.optional(zDecisionDefinitionId),
-  decisionDefinitionName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  decisionDefinitionId: zDecisionDefinitionId,
+  decisionDefinitionName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the decision which was evaluated."
-  })),
-  decisionDefinitionVersion: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  }),
+  decisionDefinitionVersion: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The version of the decision which was evaluated."
-  })),
+  }),
   decisionDefinitionType: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The type of the decision which was evaluated."
   }),
-  output: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  output: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "JSON document that will instantiate the result of the decision which was evaluated.\n"
-  })),
-  tenantId: import_zod.z.optional(zTenantId),
+  }),
+  tenantId: zTenantId,
   matchedRules: import_zod.z.array(zMatchedDecisionRuleItem).register(import_zod.z.globalRegistry, {
     description: "The decision rules that matched within this decision evaluation."
   }),
   evaluatedInputs: import_zod.z.array(zEvaluatedDecisionInputItem).register(import_zod.z.globalRegistry, {
     description: "The decision inputs that were evaluated within this decision evaluation."
   }),
-  decisionDefinitionKey: import_zod.z.optional(zDecisionDefinitionKey),
-  decisionEvaluationInstanceKey: import_zod.z.optional(zDecisionEvaluationInstanceKey)
+  decisionDefinitionKey: zDecisionDefinitionKey,
+  decisionEvaluationInstanceKey: zDecisionEvaluationInstanceKey
 }).register(import_zod.z.globalRegistry, {
   description: "A decision that was evaluated."
 });
@@ -5628,37 +5697,37 @@ var zDecisionRequirementsResult = import_zod.z.object({
   })
 });
 var zDeploymentDecisionResult = import_zod.z.object({
-  decisionDefinitionId: import_zod.z.optional(zDecisionDefinitionId),
-  version: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  decisionDefinitionId: zDecisionDefinitionId,
+  version: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The assigned decision version."
-  })),
-  name: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  name: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The DMN name of the decision, as parsed during deployment."
-  })),
-  tenantId: import_zod.z.optional(zTenantId),
-  decisionRequirementsId: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  tenantId: zTenantId,
+  decisionRequirementsId: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The dmn ID of the decision requirements graph that this decision is part of, as parsed during deployment.\n"
-  })),
-  decisionDefinitionKey: import_zod.z.optional(zDecisionDefinitionKey),
-  decisionRequirementsKey: import_zod.z.optional(zDecisionRequirementsKey)
+  }),
+  decisionDefinitionKey: zDecisionDefinitionKey,
+  decisionRequirementsKey: zDecisionRequirementsKey
 }).register(import_zod.z.globalRegistry, {
   description: "A deployed decision."
 });
 var zDeploymentDecisionRequirementsResult = import_zod.z.object({
-  decisionRequirementsId: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  decisionRequirementsId: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The id of the deployed decision requirements."
-  })),
-  decisionRequirementsName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  decisionRequirementsName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the deployed decision requirements."
-  })),
-  version: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  }),
+  version: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The version of the deployed decision requirements."
-  })),
-  resourceName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  resourceName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the resource."
-  })),
-  tenantId: import_zod.z.optional(zTenantId),
-  decisionRequirementsKey: import_zod.z.optional(zDecisionRequirementsKey)
+  }),
+  tenantId: zTenantId,
+  decisionRequirementsKey: zDecisionRequirementsKey
 }).register(import_zod.z.globalRegistry, {
   description: "Deployed decision requirements."
 });
@@ -5669,17 +5738,17 @@ var zResourceKey = import_zod.z.union([
   zDecisionDefinitionKey
 ]);
 var zDeploymentResourceResult = import_zod.z.object({
-  resourceId: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  resourceId: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The resource id of the deployed resource."
-  })),
-  resourceName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  resourceName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the deployed resource."
-  })),
-  version: import_zod.z.optional(import_zod.z.int().register(import_zod.z.globalRegistry, {
+  }),
+  version: import_zod.z.int().register(import_zod.z.globalRegistry, {
     description: "The description of the deployed resource."
-  })),
-  tenantId: import_zod.z.optional(zTenantId),
-  resourceKey: import_zod.z.optional(zResourceKey)
+  }),
+  tenantId: zTenantId,
+  resourceKey: zResourceKey
 }).register(import_zod.z.globalRegistry, {
   description: "A deployed Resource."
 });
@@ -5789,14 +5858,14 @@ var zBatchOperationResponse = import_zod.z.object({
   batchOperationKey: zBatchOperationKey,
   state: zBatchOperationStateEnum,
   batchOperationType: zBatchOperationTypeEnum,
-  startDate: import_zod.z.optional(import_zod.z.union([
+  startDate: import_zod.z.union([
     import_zod.z.iso.datetime(),
     import_zod.z.null()
-  ])),
-  endDate: import_zod.z.optional(import_zod.z.union([
+  ]),
+  endDate: import_zod.z.union([
     import_zod.z.iso.datetime(),
     import_zod.z.null()
-  ])),
+  ]),
   actorType: import_zod.z.union([
     zAuditLogActorTypeEnum,
     import_zod.z.null()
@@ -5819,17 +5888,17 @@ var zBatchOperationResponse = import_zod.z.object({
   })
 });
 var zBatchOperationItemResponse = import_zod.z.object({
-  operationType: import_zod.z.optional(zBatchOperationTypeEnum),
-  batchOperationKey: import_zod.z.optional(zBatchOperationKey),
-  itemKey: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  operationType: zBatchOperationTypeEnum,
+  batchOperationKey: zBatchOperationKey,
+  itemKey: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "Key of the item, e.g. a process instance key."
-  })),
-  processInstanceKey: import_zod.z.optional(zProcessInstanceKey),
+  }),
+  processInstanceKey: zProcessInstanceKey,
   rootProcessInstanceKey: import_zod.z.union([
     zProcessInstanceKey,
     import_zod.z.null()
   ]),
-  state: import_zod.z.optional(import_zod.z.enum([
+  state: import_zod.z.enum([
     "ACTIVE",
     "COMPLETED",
     "SKIPPED",
@@ -5837,21 +5906,22 @@ var zBatchOperationItemResponse = import_zod.z.object({
     "FAILED"
   ]).register(import_zod.z.globalRegistry, {
     description: "State of the item."
-  })),
-  processedDate: import_zod.z.optional(import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
-    description: "the date this item was processed."
-  })),
-  errorMessage: import_zod.z.optional(import_zod.z.union([
+  }),
+  processedDate: import_zod.z.union([
+    import_zod.z.iso.datetime(),
+    import_zod.z.null()
+  ]),
+  errorMessage: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ]))
+  ])
 });
 var zDeleteResourceResponse = import_zod.z.object({
   resourceKey: zResourceKey,
-  batchOperation: import_zod.z.optional(import_zod.z.union([
+  batchOperation: import_zod.z.union([
     zBatchOperationCreatedResult,
     import_zod.z.null()
-  ]))
+  ])
 });
 var zOperationReference = import_zod.z.coerce.bigint().gte(BigInt(1)).register(import_zod.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"
@@ -5912,10 +5982,6 @@ var zAuditLogResult = import_zod.z.object({
     import_zod.z.null()
   ]),
   result: zAuditLogResultEnum,
-  annotation: import_zod.z.union([
-    import_zod.z.string(),
-    import_zod.z.null()
-  ]),
   category: zAuditLogCategoryEnum,
   processDefinitionId: import_zod.z.union([
     zProcessDefinitionId,
@@ -6305,27 +6371,37 @@ var zAdvancedMessageSubscriptionStateFilter = import_zod.z.object({
 });
 var zMessageSubscriptionKey = zLongKey;
 var zMessageSubscriptionResult = import_zod.z.object({
-  messageSubscriptionKey: import_zod.z.optional(zMessageSubscriptionKey),
-  processDefinitionId: import_zod.z.optional(zProcessDefinitionId),
-  processDefinitionKey: import_zod.z.optional(zProcessDefinitionKey),
-  processInstanceKey: import_zod.z.optional(zProcessInstanceKey),
+  messageSubscriptionKey: zMessageSubscriptionKey,
+  processDefinitionId: zProcessDefinitionId,
+  processDefinitionKey: import_zod.z.union([
+    zProcessDefinitionKey,
+    import_zod.z.null()
+  ]),
+  processInstanceKey: import_zod.z.union([
+    zProcessInstanceKey,
+    import_zod.z.null()
+  ]),
   rootProcessInstanceKey: import_zod.z.union([
     zProcessInstanceKey,
     import_zod.z.null()
   ]),
-  elementId: import_zod.z.optional(zElementId),
-  elementInstanceKey: import_zod.z.optional(zElementInstanceKey),
-  messageSubscriptionState: import_zod.z.optional(zMessageSubscriptionStateEnum),
-  lastUpdatedDate: import_zod.z.optional(import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
+  elementId: zElementId,
+  elementInstanceKey: import_zod.z.union([
+    zElementInstanceKey,
+    import_zod.z.null()
+  ]),
+  messageSubscriptionState: zMessageSubscriptionStateEnum,
+  lastUpdatedDate: import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
     description: "The last updated date of the message subscription."
-  })),
-  messageName: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  }),
+  messageName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the message associated with the message subscription."
-  })),
-  correlationKey: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
-    description: "The correlation key of the message subscription."
-  })),
-  tenantId: import_zod.z.optional(zTenantId)
+  }),
+  correlationKey: import_zod.z.union([
+    import_zod.z.string(),
+    import_zod.z.null()
+  ]),
+  tenantId: zTenantId
 });
 var zAdvancedMessageSubscriptionKeyFilter = import_zod.z.object({
   "$eq": import_zod.z.optional(zMessageSubscriptionKey),
@@ -6357,16 +6433,20 @@ var zMessagePublicationResult = import_zod.z.object({
   description: "The message key of the published message."
 });
 var zCorrelatedMessageSubscriptionResult = import_zod.z.object({
-  correlationKey: import_zod.z.string().register(import_zod.z.globalRegistry, {
-    description: "The correlation key of the message."
-  }),
+  correlationKey: import_zod.z.union([
+    import_zod.z.string(),
+    import_zod.z.null()
+  ]),
   correlationTime: import_zod.z.iso.datetime().register(import_zod.z.globalRegistry, {
     description: "The time when the message was correlated."
   }),
   elementId: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The element ID that received the message."
   }),
-  elementInstanceKey: import_zod.z.optional(zElementInstanceKey),
+  elementInstanceKey: import_zod.z.union([
+    zElementInstanceKey,
+    import_zod.z.null()
+  ]),
   messageKey: zMessageKey,
   messageName: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The name of the message."
@@ -6375,7 +6455,7 @@ var zCorrelatedMessageSubscriptionResult = import_zod.z.object({
     description: "The partition ID that correlated the message."
   }),
   processDefinitionId: zProcessDefinitionId,
-  processDefinitionKey: import_zod.z.optional(zProcessDefinitionKey),
+  processDefinitionKey: zProcessDefinitionKey,
   processInstanceKey: zProcessInstanceKey,
   rootProcessInstanceKey: import_zod.z.union([
     zProcessInstanceKey,
@@ -6449,19 +6529,19 @@ var zProcessDefinitionResult = import_zod.z.object({
   })
 });
 var zProcessElementStatisticsResult = import_zod.z.object({
-  elementId: import_zod.z.optional(zElementId),
-  active: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  elementId: zElementId,
+  active: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "The total number of active instances of the element."
-  })),
-  canceled: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  }),
+  canceled: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "The total number of canceled instances of the element."
-  })),
-  incidents: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  }),
+  incidents: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "The total number of incidents for the element."
-  })),
-  completed: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  }),
+  completed: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "The total number of completed instances of the element."
-  }))
+  })
 }).register(import_zod.z.globalRegistry, {
   description: "Process element statistics response."
 });
@@ -6473,32 +6553,32 @@ var zProcessDefinitionElementStatisticsQueryResult = import_zod.z.object({
   description: "Process definition element statistics query response."
 });
 var zProcessDefinitionMessageSubscriptionStatisticsResult = import_zod.z.object({
-  processDefinitionId: import_zod.z.optional(zProcessDefinitionId),
-  tenantId: import_zod.z.optional(zTenantId),
-  processDefinitionKey: import_zod.z.optional(zProcessDefinitionKey),
-  processInstancesWithActiveSubscriptions: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  processDefinitionId: zProcessDefinitionId,
+  tenantId: zTenantId,
+  processDefinitionKey: zProcessDefinitionKey,
+  processInstancesWithActiveSubscriptions: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "The number of process instances with active message subscriptions."
-  })),
-  activeSubscriptions: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  }),
+  activeSubscriptions: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "The total number of active message subscriptions for this process definition key."
-  }))
+  })
 });
 var zProcessDefinitionInstanceStatisticsResult = import_zod.z.object({
-  processDefinitionId: import_zod.z.optional(zProcessDefinitionId),
-  tenantId: import_zod.z.optional(zTenantId),
-  latestProcessDefinitionName: import_zod.z.optional(import_zod.z.union([
+  processDefinitionId: zProcessDefinitionId,
+  tenantId: zTenantId,
+  latestProcessDefinitionName: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
-  hasMultipleVersions: import_zod.z.optional(import_zod.z.boolean().register(import_zod.z.globalRegistry, {
+  ]),
+  hasMultipleVersions: import_zod.z.boolean().register(import_zod.z.globalRegistry, {
     description: "Indicates whether multiple versions of this process definition instance are deployed."
-  })),
-  activeInstancesWithoutIncidentCount: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  }),
+  activeInstancesWithoutIncidentCount: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "Total number of currently active process instances of this definition that do not have incidents."
-  })),
-  activeInstancesWithIncidentCount: import_zod.z.optional(import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
+  }),
+  activeInstancesWithIncidentCount: import_zod.z.coerce.bigint().register(import_zod.z.globalRegistry, {
     description: "Total number of currently active process instances of this definition that have at least one incident."
-  }))
+  })
 }).register(import_zod.z.globalRegistry, {
   description: "Process definition instance statistics response."
 });
@@ -6614,10 +6694,10 @@ var zCreateProcessInstanceResult = import_zod.z.object({
   processDefinitionKey: zProcessDefinitionKey,
   processInstanceKey: zProcessInstanceKey,
   tags: zTagSet,
-  businessId: import_zod.z.optional(import_zod.z.union([
+  businessId: import_zod.z.union([
     zBusinessId,
     import_zod.z.null()
-  ]))
+  ])
 });
 var zCancelProcessInstanceRequest = import_zod.z.union([
   import_zod.z.object({
@@ -6639,18 +6719,18 @@ var zProcessInstanceCallHierarchyEntry = import_zod.z.object({
   })
 });
 var zProcessInstanceSequenceFlowResult = import_zod.z.object({
-  sequenceFlowId: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  sequenceFlowId: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "The sequence flow id."
-  })),
-  processInstanceKey: import_zod.z.optional(zProcessInstanceKey),
+  }),
+  processInstanceKey: zProcessInstanceKey,
   rootProcessInstanceKey: import_zod.z.union([
     zProcessInstanceKey,
     import_zod.z.null()
   ]),
-  processDefinitionKey: import_zod.z.optional(zProcessDefinitionKey),
-  processDefinitionId: import_zod.z.optional(zProcessDefinitionId),
-  elementId: import_zod.z.optional(zElementId),
-  tenantId: import_zod.z.optional(zTenantId)
+  processDefinitionKey: zProcessDefinitionKey,
+  processDefinitionId: zProcessDefinitionId,
+  elementId: zElementId,
+  tenantId: zTenantId
 }).register(import_zod.z.globalRegistry, {
   description: "Process instance sequence flow result."
 });
@@ -6987,6 +7067,12 @@ var zJobTimeSeriesStatisticsQuery = import_zod.z.object({
 }).register(import_zod.z.globalRegistry, {
   description: "Job time-series statistics query."
 });
+var zJobErrorStatisticsQuery = import_zod.z.object({
+  filter: zJobErrorStatisticsFilter,
+  page: import_zod.z.optional(zCursorForwardPagination)
+}).register(import_zod.z.globalRegistry, {
+  description: "Job error statistics query."
+});
 var zCursorBackwardPagination = import_zod.z.object({
   before: zStartCursor,
   limit: import_zod.z.optional(import_zod.z.int().gte(1).lte(1e4).register(import_zod.z.globalRegistry, {
@@ -7012,7 +7098,6 @@ var zAuditLogSearchQuerySortRequest = import_zod.z.object({
   field: import_zod.z.enum([
     "actorId",
     "actorType",
-    "annotation",
     "auditLogKey",
     "batchOperationKey",
     "batchOperationType",
@@ -7237,7 +7322,6 @@ var zIncidentSearchQuerySortRequest = import_zod.z.object({
     "processDefinitionId",
     "processInstanceKey",
     "errorType",
-    "errorMessage",
     "elementId",
     "elementInstanceKey",
     "creationTime",
@@ -7639,6 +7723,14 @@ var zJobTimeSeriesStatisticsQueryResult = zSearchQueryResponse.and(import_zod.z.
 }).register(import_zod.z.globalRegistry, {
   description: "Job time-series statistics query result."
 }));
+var zJobErrorStatisticsQueryResult = zSearchQueryResponse.and(import_zod.z.object({
+  items: import_zod.z.array(zJobErrorStatisticsItem).register(import_zod.z.globalRegistry, {
+    description: "The list of per-error statistics items."
+  }),
+  page: zSearchQueryPageResponse
+}).register(import_zod.z.globalRegistry, {
+  description: "Job error statistics query result."
+}));
 var zJobSearchQueryResult = zSearchQueryResponse.and(import_zod.z.object({
   items: import_zod.z.array(zJobSearchResult).register(import_zod.z.globalRegistry, {
     description: "The matching jobs."
@@ -7748,6 +7840,33 @@ var zUsageMetricsResponse = zUsageMetricsResponseItem.and(import_zod.z.object({
     description: "The usage metrics by tenants. Only available if request `withTenants` query parameter was `true`."
   })
 }));
+var zJobMetricsConfigurationResponse = import_zod.z.object({
+  enabled: import_zod.z.boolean().register(import_zod.z.globalRegistry, {
+    description: "Whether job metrics export is enabled."
+  }),
+  exportInterval: import_zod.z.string().register(import_zod.z.globalRegistry, {
+    description: "The interval at which job metrics are exported, as an ISO 8601 duration."
+  }),
+  maxWorkerNameLength: import_zod.z.int().register(import_zod.z.globalRegistry, {
+    description: "The maximum length of the worker name used in job metrics labels."
+  }),
+  maxJobTypeLength: import_zod.z.int().register(import_zod.z.globalRegistry, {
+    description: "The maximum length of the job type used in job metrics labels."
+  }),
+  maxTenantIdLength: import_zod.z.int().register(import_zod.z.globalRegistry, {
+    description: "The maximum length of the tenant ID used in job metrics labels."
+  }),
+  maxUniqueKeys: import_zod.z.int().register(import_zod.z.globalRegistry, {
+    description: "The maximum number of unique metric keys tracked for job metrics."
+  })
+}).register(import_zod.z.globalRegistry, {
+  description: "Configuration for job metrics collection and export."
+});
+var zSystemConfigurationResponse = import_zod.z.object({
+  jobMetrics: zJobMetricsConfigurationResponse
+}).register(import_zod.z.globalRegistry, {
+  description: "Envelope for all system configuration sections. Each property\nrepresents a feature area.\n"
+});
 var zTenantCreateRequest = import_zod.z.object({
   tenantId: import_zod.z.string().min(1).max(256).regex(/^[A-Za-z0-9_@.+-]+$/).register(import_zod.z.globalRegistry, {
     description: "The unique ID for the tenant. Must be 255 characters or less. Can contain letters, numbers, [`_`, `-`, `+`, `.`, `@`]."
@@ -7800,18 +7919,18 @@ var zTenantResult = import_zod.z.object({
   description: "Tenant search response item."
 });
 var zCamundaUserResult = import_zod.z.object({
-  username: import_zod.z.optional(import_zod.z.union([
+  username: import_zod.z.union([
     zUsername,
     import_zod.z.null()
-  ])),
-  displayName: import_zod.z.optional(import_zod.z.union([
+  ]),
+  displayName: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
-  email: import_zod.z.optional(import_zod.z.union([
+  ]),
+  email: import_zod.z.union([
     import_zod.z.string(),
     import_zod.z.null()
-  ])),
+  ]),
   authorizedComponents: import_zod.z.array(import_zod.z.string()).register(import_zod.z.globalRegistry, {
     description: "The web components the user is authorized to use."
   }),
@@ -8252,12 +8371,12 @@ var zVariableResultBase = import_zod.z.object({
   description: "Variable response item."
 });
 var zVariableSearchResult = zVariableResultBase.and(import_zod.z.object({
-  value: import_zod.z.optional(import_zod.z.string().register(import_zod.z.globalRegistry, {
+  value: import_zod.z.string().register(import_zod.z.globalRegistry, {
     description: "Value of this variable. Can be truncated."
-  })),
-  isTruncated: import_zod.z.optional(import_zod.z.boolean().register(import_zod.z.globalRegistry, {
+  }),
+  isTruncated: import_zod.z.boolean().register(import_zod.z.globalRegistry, {
     description: "Whether the value is truncated or not."
-  }))
+  })
 }).register(import_zod.z.globalRegistry, {
   description: "Variable search response item."
 }));
@@ -8865,6 +8984,7 @@ var zBaseProcessInstanceFilterFields = import_zod.z.object({
   parentProcessInstanceKey: import_zod.z.optional(zProcessInstanceKeyFilterProperty),
   parentElementInstanceKey: import_zod.z.optional(zElementInstanceKeyFilterProperty),
   batchOperationId: import_zod.z.optional(zStringFilterProperty),
+  batchOperationKey: import_zod.z.optional(zStringFilterProperty),
   errorMessage: import_zod.z.optional(zStringFilterProperty),
   hasRetriesLeft: import_zod.z.optional(import_zod.z.boolean().register(import_zod.z.globalRegistry, {
     description: "Whether the process has failed jobs with retries left."
@@ -9266,7 +9386,7 @@ var zDeleteDecisionInstanceData = import_zod.z.object({
     import_zod.z.null()
   ])),
   path: import_zod.z.object({
-    decisionInstanceKey: zDecisionInstanceKey
+    decisionEvaluationKey: zDecisionEvaluationKey
   }),
   query: import_zod.z.optional(import_zod.z.never())
 });
@@ -9824,6 +9944,12 @@ var zGetJobTimeSeriesStatisticsData = import_zod.z.object({
   query: import_zod.z.optional(import_zod.z.never())
 });
 var zGetJobTimeSeriesStatisticsResponse = zJobTimeSeriesStatisticsQueryResult;
+var zGetJobErrorStatisticsData = import_zod.z.object({
+  body: zJobErrorStatisticsQuery,
+  path: import_zod.z.optional(import_zod.z.never()),
+  query: import_zod.z.optional(import_zod.z.never())
+});
+var zGetJobErrorStatisticsResponse = zJobErrorStatisticsQueryResult;
 var zGetLicenseData = import_zod.z.object({
   body: import_zod.z.optional(import_zod.z.never()),
   path: import_zod.z.optional(import_zod.z.never()),
@@ -10412,6 +10538,12 @@ var zGetUsageMetricsData = import_zod.z.object({
   })
 });
 var zGetUsageMetricsResponse = zUsageMetricsResponse;
+var zGetSystemConfigurationData = import_zod.z.object({
+  body: import_zod.z.optional(import_zod.z.never()),
+  path: import_zod.z.optional(import_zod.z.never()),
+  query: import_zod.z.optional(import_zod.z.never())
+});
+var zGetSystemConfigurationResponse = zSystemConfigurationResponse;
 var zCreateTenantData = import_zod.z.object({
   body: zTenantCreateRequest,
   path: import_zod.z.optional(import_zod.z.never()),
@@ -12353,7 +12485,7 @@ function createLogger(opts = {}) {
 }
 
 // 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 {
@@ -13380,34 +13512,307 @@ var BackpressureManager = class {
         }
       }
     }
-  }
-};
+  }
+};
+
+// src/runtime/jobWorker.ts
+var JobActionReceipt = "JOB_ACTION_RECEIPT";
+var _workerCounter = 0;
+var DEFAULT_LONGPOLL_TIMEOUT = 0;
+var JobWorker = class {
+  _client;
+  _cfg;
+  _name;
+  _activeJobs = 0;
+  _stopped = false;
+  _pollTimer = null;
+  _inFlightActivation = null;
+  // CancelablePromise-like
+  _log;
+  constructor(client2, cfg) {
+    this._client = client2;
+    this._cfg = { pollIntervalMs: 1, autoStart: true, validateSchemas: false, ...cfg };
+    this._name = cfg.workerName || `worker-${cfg.jobType}-${++_workerCounter}`;
+    this._log = this._client.logger().scope(`worker:${this._name}`);
+    if (cfg.maxBackoffTimeMs !== void 0) {
+      this._log.debug(() => [
+        "worker.config.deprecated",
+        { maxBackoffTimeMs: cfg.maxBackoffTimeMs }
+      ]);
+    }
+    if (this._cfg.autoStart) this.start();
+  }
+  get name() {
+    return this._name;
+  }
+  get activeJobs() {
+    return this._activeJobs;
+  }
+  get stopped() {
+    return this._stopped;
+  }
+  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");
+  }
+  /**
+   * Gracefully stop the worker: prevent new polls, allow any in-flight activation to finish
+   * without cancellation, and wait for currently active jobs to drain (be acknowledged) up to waitUpToMs.
+   * If timeout is reached, falls back to hard stop logic (cancels activation if still pending).
+   */
+  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 };
+  }
+  _scheduleNext(delayMs) {
+    if (this._stopped) return;
+    this._pollTimer = setTimeout(() => this._poll(), delayMs);
+  }
+  async _poll() {
+    this._pollTimer = null;
+    if (this._stopped) return;
+    if (this._activeJobs >= this._cfg.maxParallelJobs) {
+      this._scheduleNext(this._cfg.pollIntervalMs);
+      return;
+    }
+    const batchSize = this._cfg.maxParallelJobs - this._activeJobs;
+    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_TIMEOUT,
+      timeout: this._cfg.jobTimeoutMs,
+      // API expects `fetchVariable`; map from config `fetchVariables`
+      ...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).catch((err) => {
+        this._log.error("job.handler.unexpected", err);
+      });
+    }
+  }
+  async _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());
+          await 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());
+          await this._failValidation(raw, "Invalid custom headers");
+          return;
+        }
+        headers = parsed.data;
+      }
+    }
+    const job = Object.assign(raw, { variables, customHeaders: headers });
+    try {
+      const receipt = await this._cfg.jobHandler(job);
+      if (!job.acknowledged) {
+        this._log.warn("job.handler.noAction", { jobKey: raw.jobKey });
+      }
+      return receipt;
+    } catch (e) {
+      this._log.error("job.handler.error", e);
+      try {
+        const retries = raw.retries;
+        await this._client.failJob({
+          jobKey: raw.jobKey,
+          errorMessage: e?.message || "Handler error",
+          retries: typeof retries === "number" ? Math.max(0, retries - 1) : 0
+        });
+      } catch (failErr) {
+        this._log.error("job.fail.error", failErr);
+      }
+      return JobActionReceipt;
+    } finally {
+      this._decrementOnce();
+    }
+  }
+  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();
+    }
+  }
+  _decrementOnce() {
+    this._activeJobs = Math.max(0, this._activeJobs - 1);
+  }
+};
+
+// 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/jobWorker.ts
-var JobActionReceipt = "JOB_ACTION_RECEIPT";
-var _workerCounter = 0;
-var DEFAULT_LONGPOLL_TIMEOUT = 0;
-var JobWorker = class {
+// 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;
-  // CancelablePromise-like
   _log;
-  constructor(client2, cfg) {
+  _jobQueue = [];
+  constructor(client2, pool, cfg) {
     this._client = client2;
+    this._pool = pool;
     this._cfg = { pollIntervalMs: 1, autoStart: true, validateSchemas: false, ...cfg };
-    this._name = cfg.workerName || `worker-${cfg.jobType}-${++_workerCounter}`;
+    this._name = cfg.workerName || `threaded-worker-${cfg.jobType}-${++_workerCounter2}`;
     this._log = this._client.logger().scope(`worker:${this._name}`);
-    if (cfg.maxBackoffTimeMs !== void 0) {
-      this._log.debug(() => [
-        "worker.config.deprecated",
-        { maxBackoffTimeMs: cfg.maxBackoffTimeMs }
-      ]);
-    }
     if (this._cfg.autoStart) this.start();
   }
   get name() {
@@ -13419,6 +13824,18 @@ var JobWorker = class {
   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;
@@ -13444,11 +13861,6 @@ var JobWorker = class {
     }
     this._log.info("worker.stop");
   }
-  /**
-   * Gracefully stop the worker: prevent new polls, allow any in-flight activation to finish
-   * without cancellation, and wait for currently active jobs to drain (be acknowledged) up to waitUpToMs.
-   * If timeout is reached, falls back to hard stop logic (cancels activation if still pending).
-   */
   async stopGracefully(opts) {
     const waitUpToMs = opts?.waitUpToMs ?? 5e3;
     const checkIntervalMs = opts?.checkIntervalMs ?? 10;
@@ -13487,6 +13899,47 @@ var JobWorker = class {
     }
     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);
@@ -13494,11 +13947,13 @@ var JobWorker = class {
   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 batchSize = this._cfg.maxParallelJobs - this._activeJobs;
+    const availableThreads = this._pool.idleCount;
+    const batchSize = Math.min(this._cfg.maxParallelJobs - this._activeJobs, availableThreads);
     if (batchSize <= 0) {
       this._scheduleNext(this._cfg.pollIntervalMs);
       return;
@@ -13507,9 +13962,8 @@ var JobWorker = class {
       type: this._cfg.jobType,
       worker: this._name,
       maxJobsToActivate: batchSize,
-      requestTimeout: this._cfg.pollTimeoutMs ?? DEFAULT_LONGPOLL_TIMEOUT,
+      requestTimeout: this._cfg.pollTimeoutMs ?? DEFAULT_LONGPOLL_TIMEOUT2,
       timeout: this._cfg.jobTimeoutMs,
-      // API expects `fetchVariable`; map from config `fetchVariables`
       ...this._cfg.fetchVariables && this._cfg.fetchVariables.length > 0 ? { fetchVariable: this._cfg.fetchVariables } : {}
     };
     this._log.debug(() => ["activation.request", { batchSize }]);
@@ -13538,12 +13992,10 @@ var JobWorker = class {
     this._activeJobs += result.length;
     this._scheduleNext(0);
     for (const raw of result) {
-      this._handleJob(raw).catch((err) => {
-        this._log.error("job.handler.unexpected", err);
-      });
+      this._handleJob(raw);
     }
   }
-  async _handleJob(raw) {
+  _handleJob(raw) {
     if (this._stopped) {
       this._decrementOnce();
       return;
@@ -13555,7 +14007,7 @@ var JobWorker = class {
         const parsed = this._cfg.inputSchema.safeParse(variables);
         if (!parsed.success) {
           this._log.warn("job.validation.variables.failed", parsed.error.flatten());
-          await this._failValidation(raw, "Invalid variables");
+          this._failValidation(raw, "Invalid variables");
           return;
         }
         variables = parsed.data;
@@ -13564,34 +14016,18 @@ var JobWorker = class {
         const parsed = this._cfg.customHeadersSchema.safeParse(headers);
         if (!parsed.success) {
           this._log.warn("job.validation.headers.failed", parsed.error.flatten());
-          await this._failValidation(raw, "Invalid custom headers");
+          this._failValidation(raw, "Invalid custom headers");
           return;
         }
         headers = parsed.data;
       }
     }
-    const job = Object.assign(raw, { variables, customHeaders: headers });
-    try {
-      const receipt = await this._cfg.jobHandler(job);
-      if (!job.acknowledged) {
-        this._log.warn("job.handler.noAction", { jobKey: raw.jobKey });
-      }
-      return receipt;
-    } catch (e) {
-      this._log.error("job.handler.error", e);
-      try {
-        const retries = raw.retries;
-        await this._client.failJob({
-          jobKey: raw.jobKey,
-          errorMessage: e?.message || "Handler error",
-          retries: typeof retries === "number" ? Math.max(0, retries - 1) : 0
-        });
-      } catch (failErr) {
-        this._log.error("job.fail.error", failErr);
-      }
-      return JobActionReceipt;
-    } finally {
-      this._decrementOnce();
+    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 });
     }
   }
   async _failValidation(raw, msg) {
@@ -13608,58 +14044,188 @@ var JobWorker = class {
   }
 };
 
-// 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) => {
+// src/runtime/clientProxy.ts
+function installClientCallHandler(port, client2) {
+  port.on("message", async (msg) => {
+    if (msg.type !== "client-call") return;
     try {
-      await client2.failJob({ ...reason, jobKey: raw.jobKey });
-    } finally {
-      ack();
+      const fn = client2[msg.method];
+      if (typeof fn !== "function") {
+        throw new Error(`CamundaClient has no method '${msg.method}'`);
+      }
+      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);
     }
-    return JobActionReceipt;
-  };
-  job.error = async (error) => {
-    try {
-      await client2.throwJobError({ ...error, jobKey: raw.jobKey });
-    } finally {
-      ack();
+  });
+}
+
+// src/runtime/threadPool.ts
+var import_meta = {};
+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(() => {
+      });
     }
-    return JobActionReceipt;
-  };
-  job.cancelWorkflow = async () => {
-    try {
-      await client2.cancelProcessInstance({
-        processInstanceKey: raw.processInstanceKey
+    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;
+        }
+        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"));
+            }
+          }
+          return;
+        }
       });
-    } finally {
-      ack();
+      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);
     }
-    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;
-}
+    this._log.info(() => ["thread-pool.init", { size, entryPath }]);
+  }
+};
 
 // src/runtime/responseEvaluation.ts
 function evaluateSdkResponse(raw, opts) {
@@ -13755,6 +14321,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() {
@@ -14050,7 +14618,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 {
@@ -14059,6 +14627,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) => {
@@ -16069,9 +16648,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);
@@ -17839,6 +18418,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;
@@ -18997,6 +19630,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;
@@ -23511,6 +24186,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.
@@ -23647,7 +24347,7 @@ function createCamundaFpClient(options) {
 
 // src/gen/types.gen.ts
 function assertConstraint(value, label, c) {
-  if (c.pattern && !new RegExp(c.pattern).test(value)) throw new Error(`\x1B[31mInvalid pattern for ${label}: '${value}'.\x1B[0m Needs to match: ${JSON.stringify(c)}
+  if (c.pattern && !new RegExp(c.pattern, "u").test(value)) throw new Error(`\x1B[31mInvalid pattern for ${label}: '${value}'.\x1B[0m Needs to match: ${JSON.stringify(c)}
 `);
   if (typeof c.minLength === "number" && value.length < c.minLength) throw new Error(`Value too short for ${label}`);
   if (typeof c.maxLength === "number" && value.length > c.maxLength) throw new Error(`Value too long for ${label}`);
@@ -23769,7 +24469,7 @@ var ConditionalEvaluationKey;
 var DecisionDefinitionId;
 ((DecisionDefinitionId2) => {
   function assumeExists(value) {
-    assertConstraint(value, "DecisionDefinitionId", { pattern: "^[A-Za-z0-9_@.+-]+$", minLength: 1, maxLength: 256 });
+    assertConstraint(value, "DecisionDefinitionId", { pattern: "^[\\p{L}_][\\p{L}\\p{N}_\\-\\.]*$", minLength: 1 });
     return value;
   }
   DecisionDefinitionId2.assumeExists = assumeExists;
@@ -23779,7 +24479,7 @@ var DecisionDefinitionId;
   DecisionDefinitionId2.getValue = getValue;
   function isValid(value) {
     try {
-      assertConstraint(value, "DecisionDefinitionId", { pattern: "^[A-Za-z0-9_@.+-]+$", minLength: 1, maxLength: 256 });
+      assertConstraint(value, "DecisionDefinitionId", { pattern: "^[\\p{L}_][\\p{L}\\p{N}_\\-\\.]*$", minLength: 1 });
       return true;
     } catch {
       return false;
@@ -24123,7 +24823,7 @@ var MessageSubscriptionKey;
 var ProcessDefinitionId;
 ((ProcessDefinitionId2) => {
   function assumeExists(value) {
-    assertConstraint(value, "ProcessDefinitionId", { pattern: "^[a-zA-Z_][a-zA-Z0-9_\\-\\.]*$", minLength: 1 });
+    assertConstraint(value, "ProcessDefinitionId", { pattern: "^[\\p{L}_][\\p{L}\\p{N}_\\-\\.]*$", minLength: 1 });
     return value;
   }
   ProcessDefinitionId2.assumeExists = assumeExists;
@@ -24133,7 +24833,7 @@ var ProcessDefinitionId;
   ProcessDefinitionId2.getValue = getValue;
   function isValid(value) {
     try {
-      assertConstraint(value, "ProcessDefinitionId", { pattern: "^[a-zA-Z_][a-zA-Z0-9_\\-\\.]*$", minLength: 1 });
+      assertConstraint(value, "ProcessDefinitionId", { pattern: "^[\\p{L}_][\\p{L}\\p{N}_\\-\\.]*$", minLength: 1 });
       return true;
     } catch {
       return false;