@camunda8/orchestration-cluster-api 10.0.0-alpha.14 → 10.0.0-alpha.16
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +15 -0
- package/dist/{chunk-IV7WMOID.js → chunk-RTRUW7ZX.js} +787 -106
- package/dist/chunk-RTRUW7ZX.js.map +1 -0
- package/dist/fp/index.cjs +1251 -166
- package/dist/fp/index.cjs.map +1 -1
- package/dist/fp/index.d.cts +1 -1
- package/dist/fp/index.d.ts +1 -1
- package/dist/fp/index.js +1 -1
- package/dist/{index-BNm2kRb2.d.ts → index-CODJzgmX.d.ts} +1225 -74
- package/dist/{index-DIIosqf7.d.cts → index-D1PepsDV.d.cts} +1225 -74
- package/dist/index.cjs +1271 -167
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +3 -3
- package/dist/index.d.ts +3 -3
- package/dist/index.js +20 -2
- package/dist/index.js.map +1 -1
- package/dist/{zod.gen-7PI6QBPP.js → zod.gen-EOOTXFM5.js} +446 -42
- package/dist/zod.gen-EOOTXFM5.js.map +1 -0
- package/package.json +4 -3
- package/dist/chunk-IV7WMOID.js.map +0 -1
- package/dist/zod.gen-7PI6QBPP.js.map +0 -1
|
@@ -122,11 +122,11 @@ var zAgentInstanceObjectContent = z.object({
|
|
|
122
122
|
contentType: z.string().register(z.globalRegistry, {
|
|
123
123
|
description: "The content type discriminator."
|
|
124
124
|
}),
|
|
125
|
-
object: z.
|
|
126
|
-
description: "Arbitrary structured content."
|
|
125
|
+
object: z.unknown().register(z.globalRegistry, {
|
|
126
|
+
description: "Arbitrary structured content \u2014 any valid JSON value (object, array, number, boolean, or string)."
|
|
127
127
|
})
|
|
128
128
|
}).register(z.globalRegistry, {
|
|
129
|
-
description: "An arbitrary structured content block."
|
|
129
|
+
description: "An arbitrary structured content block. Accepts any valid JSON value:\nobjects, arrays, numbers, booleans, or strings.\nUse TEXT content for human-readable natural language;\nuse OBJECT content for machine-readable structured data.\n"
|
|
130
130
|
});
|
|
131
131
|
var zAgentInstanceMessageContentTypeEnum = z.enum([
|
|
132
132
|
"TEXT",
|
|
@@ -154,15 +154,18 @@ var zAgentInstanceToolCall = z.object({
|
|
|
154
154
|
description: "A tool call associated with a history item. Used in both ASSISTANT and TOOL_RESULT items.\nASSISTANT items carry arguments; TOOL_RESULT items carry arguments as null.\n"
|
|
155
155
|
});
|
|
156
156
|
var zAgentInstanceHistoryItemMetrics = z.object({
|
|
157
|
-
inputTokens: z.
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
157
|
+
inputTokens: z.union([
|
|
158
|
+
z.coerce.number().int(),
|
|
159
|
+
z.null()
|
|
160
|
+
]),
|
|
161
|
+
outputTokens: z.union([
|
|
162
|
+
z.coerce.number().int(),
|
|
163
|
+
z.null()
|
|
164
|
+
]),
|
|
165
|
+
durationMs: z.union([
|
|
166
|
+
z.coerce.number().int(),
|
|
167
|
+
z.null()
|
|
168
|
+
])
|
|
166
169
|
}).register(z.globalRegistry, {
|
|
167
170
|
description: "Per-call token and latency metrics for an ASSISTANT history item."
|
|
168
171
|
});
|
|
@@ -282,6 +285,7 @@ var zPermissionTypeEnum = z.enum([
|
|
|
282
285
|
"CREATE_BATCH_OPERATION_MIGRATE_PROCESS_INSTANCE",
|
|
283
286
|
"CREATE_BATCH_OPERATION_MODIFY_PROCESS_INSTANCE",
|
|
284
287
|
"CREATE_BATCH_OPERATION_RESOLVE_INCIDENT",
|
|
288
|
+
"CREATE_BATCH_OPERATION_SUSPEND_PROCESS_INSTANCE",
|
|
285
289
|
"CREATE_BATCH_OPERATION_UPDATE_JOB",
|
|
286
290
|
"CREATE_DECISION_INSTANCE",
|
|
287
291
|
"CREATE_PROCESS_INSTANCE",
|
|
@@ -296,6 +300,7 @@ var zPermissionTypeEnum = z.enum([
|
|
|
296
300
|
"DELETE_TASK_LISTENER",
|
|
297
301
|
"EVALUATE",
|
|
298
302
|
"MODIFY_PROCESS_INSTANCE",
|
|
303
|
+
"PAUSE",
|
|
299
304
|
"READ",
|
|
300
305
|
"READ_DECISION_DEFINITION",
|
|
301
306
|
"READ_DECISION_INSTANCE",
|
|
@@ -305,6 +310,9 @@ var zPermissionTypeEnum = z.enum([
|
|
|
305
310
|
"READ_USAGE_METRIC",
|
|
306
311
|
"READ_USER_TASK",
|
|
307
312
|
"READ_TASK_LISTENER",
|
|
313
|
+
"RESTORE",
|
|
314
|
+
"REVEAL",
|
|
315
|
+
"SUSPEND_PROCESS_INSTANCE",
|
|
308
316
|
"UPDATE",
|
|
309
317
|
"UPDATE_PROCESS_INSTANCE",
|
|
310
318
|
"UPDATE_USER_TASK",
|
|
@@ -315,12 +323,14 @@ var zPermissionTypeEnum = z.enum([
|
|
|
315
323
|
var zResourceTypeEnum = z.enum([
|
|
316
324
|
"AUDIT_LOG",
|
|
317
325
|
"AUTHORIZATION",
|
|
326
|
+
"BACKUP",
|
|
318
327
|
"BATCH",
|
|
319
328
|
"CLUSTER_VARIABLE",
|
|
320
329
|
"COMPONENT",
|
|
321
330
|
"DECISION_DEFINITION",
|
|
322
331
|
"DECISION_REQUIREMENTS_DEFINITION",
|
|
323
332
|
"DOCUMENT",
|
|
333
|
+
"EXPORTER",
|
|
324
334
|
"EXPRESSION",
|
|
325
335
|
"GLOBAL_LISTENER",
|
|
326
336
|
"GROUP",
|
|
@@ -329,6 +339,7 @@ var zResourceTypeEnum = z.enum([
|
|
|
329
339
|
"PROCESS_DEFINITION",
|
|
330
340
|
"RESOURCE",
|
|
331
341
|
"ROLE",
|
|
342
|
+
"SECRET",
|
|
332
343
|
"SYSTEM",
|
|
333
344
|
"TENANT",
|
|
334
345
|
"USER",
|
|
@@ -434,6 +445,8 @@ var zBatchOperationTypeEnum = z.enum([
|
|
|
434
445
|
"MIGRATE_PROCESS_INSTANCE",
|
|
435
446
|
"MODIFY_PROCESS_INSTANCE",
|
|
436
447
|
"RESOLVE_INCIDENT",
|
|
448
|
+
"RESUME_PROCESS_INSTANCE",
|
|
449
|
+
"SUSPEND_PROCESS_INSTANCE",
|
|
437
450
|
"UPDATE_JOB",
|
|
438
451
|
"UPDATE_VARIABLE"
|
|
439
452
|
]).register(z.globalRegistry, {
|
|
@@ -444,6 +457,12 @@ var zClockPinRequest = z.object({
|
|
|
444
457
|
description: "The exact time in epoch milliseconds to which the clock should be pinned."
|
|
445
458
|
})
|
|
446
459
|
});
|
|
460
|
+
var zClusterVariableKindEnum = z.enum([
|
|
461
|
+
"JSON",
|
|
462
|
+
"SECRET_REFERENCE"
|
|
463
|
+
]).register(z.globalRegistry, {
|
|
464
|
+
description: "The kind of a cluster variable. JSON is the default. SECRET_REFERENCE allows the value to contain camunda.secrets.X references that are resolved at job activation time."
|
|
465
|
+
});
|
|
447
466
|
var zClusterVariableScopeEnum = z.enum([
|
|
448
467
|
"GLOBAL",
|
|
449
468
|
"TENANT"
|
|
@@ -453,7 +472,13 @@ var zClusterVariableScopeEnum = z.enum([
|
|
|
453
472
|
var zUpdateClusterVariableRequest = z.object({
|
|
454
473
|
value: z.record(z.string(), z.unknown()).register(z.globalRegistry, {
|
|
455
474
|
description: "The new value of the cluster variable. Can be any JSON object or primitive value. Will be serialized as a JSON string in responses."
|
|
456
|
-
})
|
|
475
|
+
}),
|
|
476
|
+
metadata: z.optional(z.record(z.string(), z.union([
|
|
477
|
+
z.string(),
|
|
478
|
+
z.number()
|
|
479
|
+
])).register(z.globalRegistry, {
|
|
480
|
+
description: "A generic key-value metadata bag attached to the cluster variable. Values must be strings or numbers. Limited to 100 entries and a configurable maximum serialized size (default: 100 entries at max key length of a cluster variable name (256 chars) plus the maximum value length, 8192 characters)."
|
|
481
|
+
}))
|
|
457
482
|
});
|
|
458
483
|
var zPartition = z.object({
|
|
459
484
|
partitionId: z.int().register(z.globalRegistry, {
|
|
@@ -472,13 +497,26 @@ var zPartition = z.object({
|
|
|
472
497
|
"dead"
|
|
473
498
|
]).register(z.globalRegistry, {
|
|
474
499
|
description: "Describes the current health of the partition."
|
|
500
|
+
}),
|
|
501
|
+
state: z.enum([
|
|
502
|
+
"unknown",
|
|
503
|
+
"joining",
|
|
504
|
+
"active",
|
|
505
|
+
"leaving",
|
|
506
|
+
"recovering"
|
|
507
|
+
]).register(z.globalRegistry, {
|
|
508
|
+
description: "Describes the current operational state of the partition within the cluster configuration.\n"
|
|
475
509
|
})
|
|
476
510
|
}).register(z.globalRegistry, {
|
|
477
511
|
description: "Provides information on a partition within a broker node."
|
|
478
512
|
});
|
|
479
513
|
var zBrokerInfo = z.object({
|
|
480
514
|
nodeId: z.int().register(z.globalRegistry, {
|
|
481
|
-
description: "The unique (within a cluster
|
|
515
|
+
description: "The node ID for the broker. The uniqueness of this identifier depends if the cluster is zone-aware or not. - non zone-aware: (default) nodeId is unique across the cluster - zone-aware: (opt-in) nodeId is unique only within its zone. If you are migrating to a zone aware cluster, you must use `brokerId` instead. This property is deprecated, as it's been replaced by `brokerId`.\n"
|
|
516
|
+
}),
|
|
517
|
+
brokerId: z.string().register(z.globalRegistry, {
|
|
518
|
+
description: `The unique (within a cluster) broker identifier. When the cluster is not zoned, then it's a string that represents the nodeId (an integer). When the cluster is zoned, instead, it's of the form "$zoneName_$nodeId", providing uniqueness even across zones.
|
|
519
|
+
`
|
|
482
520
|
}),
|
|
483
521
|
host: z.string().register(z.globalRegistry, {
|
|
484
522
|
description: "The hostname for reaching the broker."
|
|
@@ -521,6 +559,43 @@ var zTopologyResponse = z.object({
|
|
|
521
559
|
}).register(z.globalRegistry, {
|
|
522
560
|
description: "The response of a topology request."
|
|
523
561
|
});
|
|
562
|
+
var zClusterModeChangeOperation = z.object({
|
|
563
|
+
operation: z.string().register(z.globalRegistry, {
|
|
564
|
+
description: "The type of the operation."
|
|
565
|
+
}),
|
|
566
|
+
mode: z.union([
|
|
567
|
+
z.string(),
|
|
568
|
+
z.null()
|
|
569
|
+
])
|
|
570
|
+
}).register(z.globalRegistry, {
|
|
571
|
+
description: "A single operation that is part of a cluster mode change."
|
|
572
|
+
});
|
|
573
|
+
var zClusterModeChangeResponse = z.object({
|
|
574
|
+
changeId: z.string().register(z.globalRegistry, {
|
|
575
|
+
description: "The ID of the cluster change that was triggered by the request."
|
|
576
|
+
}),
|
|
577
|
+
plannedChanges: z.array(zClusterModeChangeOperation).register(z.globalRegistry, {
|
|
578
|
+
description: "The ordered list of operations that will be applied to complete the change."
|
|
579
|
+
})
|
|
580
|
+
}).register(z.globalRegistry, {
|
|
581
|
+
description: "The planned changes resulting from a cluster mode transition request."
|
|
582
|
+
});
|
|
583
|
+
var zRestoreRequest = z.object({
|
|
584
|
+
from: z.optional(z.union([
|
|
585
|
+
z.iso.datetime(),
|
|
586
|
+
z.null()
|
|
587
|
+
])),
|
|
588
|
+
to: z.optional(z.union([
|
|
589
|
+
z.iso.datetime(),
|
|
590
|
+
z.null()
|
|
591
|
+
])),
|
|
592
|
+
backupIds: z.optional(z.union([
|
|
593
|
+
z.array(z.coerce.number().int()),
|
|
594
|
+
z.null()
|
|
595
|
+
]))
|
|
596
|
+
}).register(z.globalRegistry, {
|
|
597
|
+
description: "Describes a restore request. Provide either a list of backup IDs or a time range (`from`/`to`) that selects the backups to restore; the two are mutually exclusive."
|
|
598
|
+
});
|
|
524
599
|
var zStartCursor = z.string().regex(/^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}(?:==)?|[A-Za-z0-9+\/]{3}=)?$/).register(z.globalRegistry, {
|
|
525
600
|
description: "The start cursor in a search query result set."
|
|
526
601
|
});
|
|
@@ -858,6 +933,40 @@ var zAdvancedBatchOperationItemStateFilter = z.object({
|
|
|
858
933
|
}).register(z.globalRegistry, {
|
|
859
934
|
description: "Advanced BatchOperationItemStateEnum filter."
|
|
860
935
|
});
|
|
936
|
+
var zAdvancedMetadataValueFilter = z.object({
|
|
937
|
+
"$eq": z.optional(z.union([
|
|
938
|
+
z.string(),
|
|
939
|
+
z.number()
|
|
940
|
+
])),
|
|
941
|
+
"$neq": z.optional(z.union([
|
|
942
|
+
z.string(),
|
|
943
|
+
z.number()
|
|
944
|
+
])),
|
|
945
|
+
"$exists": z.optional(z.boolean().register(z.globalRegistry, {
|
|
946
|
+
description: "Checks if the metadata key exists."
|
|
947
|
+
})),
|
|
948
|
+
"$gt": z.optional(z.number().register(z.globalRegistry, {
|
|
949
|
+
description: "Greater than comparison with the provided value."
|
|
950
|
+
})),
|
|
951
|
+
"$gte": z.optional(z.number().register(z.globalRegistry, {
|
|
952
|
+
description: "Greater than or equal comparison with the provided value."
|
|
953
|
+
})),
|
|
954
|
+
"$lt": z.optional(z.number().register(z.globalRegistry, {
|
|
955
|
+
description: "Lower than comparison with the provided value."
|
|
956
|
+
})),
|
|
957
|
+
"$lte": z.optional(z.number().register(z.globalRegistry, {
|
|
958
|
+
description: "Lower than or equal comparison with the provided value."
|
|
959
|
+
})),
|
|
960
|
+
"$in": z.optional(z.array(z.union([
|
|
961
|
+
z.string(),
|
|
962
|
+
z.number()
|
|
963
|
+
])).register(z.globalRegistry, {
|
|
964
|
+
description: "Checks if the property matches any of the provided values."
|
|
965
|
+
})),
|
|
966
|
+
"$like": z.optional(zLikeFilter)
|
|
967
|
+
}).register(z.globalRegistry, {
|
|
968
|
+
description: "Advanced filter on a metadata value (string or number)."
|
|
969
|
+
});
|
|
861
970
|
var zAdvancedClusterVariableScopeFilter = z.object({
|
|
862
971
|
"$eq": z.optional(zClusterVariableScopeEnum),
|
|
863
972
|
"$neq": z.optional(zClusterVariableScopeEnum),
|
|
@@ -871,6 +980,19 @@ var zAdvancedClusterVariableScopeFilter = z.object({
|
|
|
871
980
|
}).register(z.globalRegistry, {
|
|
872
981
|
description: "Advanced ClusterVariableScopeEnum filter."
|
|
873
982
|
});
|
|
983
|
+
var zAdvancedClusterVariableKindFilter = z.object({
|
|
984
|
+
"$eq": z.optional(zClusterVariableKindEnum),
|
|
985
|
+
"$neq": z.optional(zClusterVariableKindEnum),
|
|
986
|
+
"$exists": z.optional(z.boolean().register(z.globalRegistry, {
|
|
987
|
+
description: "Checks if the current property exists."
|
|
988
|
+
})),
|
|
989
|
+
"$in": z.optional(z.array(zClusterVariableKindEnum).register(z.globalRegistry, {
|
|
990
|
+
description: "Checks if the property matches any of the provided values."
|
|
991
|
+
})),
|
|
992
|
+
"$like": z.optional(zLikeFilter)
|
|
993
|
+
}).register(z.globalRegistry, {
|
|
994
|
+
description: "Advanced ClusterVariableKindEnum filter."
|
|
995
|
+
});
|
|
874
996
|
var zAdvancedDecisionInstanceStateFilter = z.object({
|
|
875
997
|
"$eq": z.optional(zDecisionInstanceStateEnum),
|
|
876
998
|
"$neq": z.optional(zDecisionInstanceStateEnum),
|
|
@@ -1230,7 +1352,14 @@ var zCreateClusterVariableRequest = z.object({
|
|
|
1230
1352
|
name: zClusterVariableName,
|
|
1231
1353
|
value: z.record(z.string(), z.unknown()).register(z.globalRegistry, {
|
|
1232
1354
|
description: "The value of the cluster variable. Can be any JSON object or primitive value. Will be serialized as a JSON string in responses."
|
|
1233
|
-
})
|
|
1355
|
+
}),
|
|
1356
|
+
metadata: z.optional(z.record(z.string(), z.union([
|
|
1357
|
+
z.string(),
|
|
1358
|
+
z.number()
|
|
1359
|
+
])).register(z.globalRegistry, {
|
|
1360
|
+
description: "A generic key-value metadata bag attached to the cluster variable. Values must be strings or numbers. Limited to 100 entries and a configurable maximum serialized size (default: 100 entries at max key length of a cluster variable name (256 chars) plus the maximum value length, 8192 characters)."
|
|
1361
|
+
})),
|
|
1362
|
+
kind: z.optional(zClusterVariableKindEnum)
|
|
1234
1363
|
});
|
|
1235
1364
|
var zClusterVariableResultBase = z.object({
|
|
1236
1365
|
name: zClusterVariableName,
|
|
@@ -1238,7 +1367,14 @@ var zClusterVariableResultBase = z.object({
|
|
|
1238
1367
|
tenantId: z.union([
|
|
1239
1368
|
z.string(),
|
|
1240
1369
|
z.null()
|
|
1241
|
-
])
|
|
1370
|
+
]),
|
|
1371
|
+
metadata: z.record(z.string(), z.union([
|
|
1372
|
+
z.string(),
|
|
1373
|
+
z.number()
|
|
1374
|
+
])).register(z.globalRegistry, {
|
|
1375
|
+
description: "A generic key-value metadata bag attached to the cluster variable. Values are strings or numbers."
|
|
1376
|
+
}),
|
|
1377
|
+
kind: zClusterVariableKindEnum
|
|
1242
1378
|
}).register(z.globalRegistry, {
|
|
1243
1379
|
description: "Cluster variable response item."
|
|
1244
1380
|
});
|
|
@@ -1266,8 +1402,8 @@ var zTagSet = z.array(zTag).max(10).register(z.globalRegistry, {
|
|
|
1266
1402
|
var zBusinessId = z.string().min(1).max(256).register(z.globalRegistry, {
|
|
1267
1403
|
description: "An optional, user-defined string identifier that identifies the process instance\nwithin the scope of a process definition (scoped by tenant). If provided and uniqueness\nenforcement is enabled, the engine will reject creation if another root process instance\nwith the same business id is already active for the same process definition.\nNote that any active child process instances with the same business id are not taken into account.\n"
|
|
1268
1404
|
});
|
|
1269
|
-
var
|
|
1270
|
-
description: "A client-provided sequential integer identifying
|
|
1405
|
+
var zLoopIterationId = z.int().gte(1).register(z.globalRegistry, {
|
|
1406
|
+
description: "A client-provided sequential integer identifying one pass through the agent\nfeedback loop: one LLM call, its tool dispatches, and their results. Must be\na positive integer, increasing with each loopIteration. Established by the\nconnector when appending the first history item of a loopIteration.\n"
|
|
1271
1407
|
});
|
|
1272
1408
|
var zAdvancedElementIdFilter = z.object({
|
|
1273
1409
|
"$eq": z.optional(zElementId),
|
|
@@ -1314,6 +1450,7 @@ var zIncidentErrorTypeEnum = z.enum([
|
|
|
1314
1450
|
"JOB_NO_RETRIES",
|
|
1315
1451
|
"MESSAGE_SIZE_EXCEEDED",
|
|
1316
1452
|
"RESOURCE_NOT_FOUND",
|
|
1453
|
+
"SECRET_RESOLUTION_ERROR",
|
|
1317
1454
|
"TASK_LISTENER_NO_RETRIES",
|
|
1318
1455
|
"UNHANDLED_ERROR_EVENT",
|
|
1319
1456
|
"UNKNOWN",
|
|
@@ -1514,7 +1651,11 @@ var zJobFailRequest = z.object({
|
|
|
1514
1651
|
})).default(0),
|
|
1515
1652
|
variables: z.optional(z.record(z.string(), z.unknown()).register(z.globalRegistry, {
|
|
1516
1653
|
description: "JSON object that will instantiate the variables at the local scope of the job's associated task.\n"
|
|
1517
|
-
}))
|
|
1654
|
+
})),
|
|
1655
|
+
leaseToken: z.optional(z.union([
|
|
1656
|
+
z.string(),
|
|
1657
|
+
z.null()
|
|
1658
|
+
]))
|
|
1518
1659
|
});
|
|
1519
1660
|
var zJobErrorRequest = z.object({
|
|
1520
1661
|
errorCode: z.string().register(z.globalRegistry, {
|
|
@@ -1527,6 +1668,10 @@ var zJobErrorRequest = z.object({
|
|
|
1527
1668
|
variables: z.optional(z.union([
|
|
1528
1669
|
z.record(z.string(), z.unknown()),
|
|
1529
1670
|
z.null()
|
|
1671
|
+
])),
|
|
1672
|
+
leaseToken: z.optional(z.union([
|
|
1673
|
+
z.string(),
|
|
1674
|
+
z.null()
|
|
1530
1675
|
]))
|
|
1531
1676
|
});
|
|
1532
1677
|
var zJobResultCorrections = z.union([
|
|
@@ -1614,7 +1759,15 @@ var zJobCompletionRequest = z.object({
|
|
|
1614
1759
|
z.record(z.string(), z.unknown()),
|
|
1615
1760
|
z.null()
|
|
1616
1761
|
])),
|
|
1617
|
-
result: z.optional(zJobResult)
|
|
1762
|
+
result: z.optional(zJobResult),
|
|
1763
|
+
leaseToken: z.optional(z.union([
|
|
1764
|
+
z.string(),
|
|
1765
|
+
z.null()
|
|
1766
|
+
])),
|
|
1767
|
+
businessId: z.optional(z.union([
|
|
1768
|
+
zBusinessId,
|
|
1769
|
+
z.null()
|
|
1770
|
+
]))
|
|
1618
1771
|
});
|
|
1619
1772
|
var zJobChangeset = z.object({
|
|
1620
1773
|
retries: z.optional(z.union([
|
|
@@ -1660,7 +1813,11 @@ var zJobActivationRequest = z.object({
|
|
|
1660
1813
|
tenantIds: z.optional(z.array(zTenantId).register(z.globalRegistry, {
|
|
1661
1814
|
description: "A list of IDs of tenants for which to activate jobs."
|
|
1662
1815
|
})),
|
|
1663
|
-
tenantFilter: z.optional(zTenantFilterEnum)
|
|
1816
|
+
tenantFilter: z.optional(zTenantFilterEnum),
|
|
1817
|
+
withLease: z.optional(z.union([
|
|
1818
|
+
z.boolean(),
|
|
1819
|
+
z.null()
|
|
1820
|
+
]))
|
|
1664
1821
|
});
|
|
1665
1822
|
var zJobStateEnum = z.enum([
|
|
1666
1823
|
"CANCELED",
|
|
@@ -1671,6 +1828,7 @@ var zJobStateEnum = z.enum([
|
|
|
1671
1828
|
"MIGRATED",
|
|
1672
1829
|
"PRIORITY_UPDATED",
|
|
1673
1830
|
"RETRIES_UPDATED",
|
|
1831
|
+
"TIMEOUT_UPDATED",
|
|
1674
1832
|
"TIMED_OUT"
|
|
1675
1833
|
]).register(z.globalRegistry, {
|
|
1676
1834
|
description: "The state of the job."
|
|
@@ -2100,8 +2258,8 @@ var zAgentInstanceHistoryItemRequest = z.object({
|
|
|
2100
2258
|
jobLease: z.string().register(z.globalRegistry, {
|
|
2101
2259
|
description: "Opaque lease token received from the job activation response."
|
|
2102
2260
|
}),
|
|
2103
|
-
|
|
2104
|
-
|
|
2261
|
+
loopIteration: z.optional(z.union([
|
|
2262
|
+
zLoopIterationId,
|
|
2105
2263
|
z.null()
|
|
2106
2264
|
])),
|
|
2107
2265
|
role: zAgentInstanceHistoryRoleEnum,
|
|
@@ -2227,6 +2385,9 @@ var zActivatedJobResult = z.object({
|
|
|
2227
2385
|
description: "All variables visible to the task scope, computed at activation time."
|
|
2228
2386
|
}),
|
|
2229
2387
|
tenantId: zTenantId,
|
|
2388
|
+
physicalTenantId: z.string().register(z.globalRegistry, {
|
|
2389
|
+
description: "The ID of the physical tenant that the job-activation request was routed to;\nthe default physical tenant when the request did not specify one.\n"
|
|
2390
|
+
}),
|
|
2230
2391
|
jobKey: zJobKey,
|
|
2231
2392
|
processInstanceKey: zProcessInstanceKey,
|
|
2232
2393
|
processDefinitionKey: zProcessDefinitionKey,
|
|
@@ -2248,7 +2409,11 @@ var zActivatedJobResult = z.object({
|
|
|
2248
2409
|
]),
|
|
2249
2410
|
priority: z.int().register(z.globalRegistry, {
|
|
2250
2411
|
description: "The priority of the job. Higher values indicate higher priority. Jobs created before 8.10 have no stored priority; the API returns 0 for such jobs.\n"
|
|
2251
|
-
})
|
|
2412
|
+
}),
|
|
2413
|
+
leaseToken: z.union([
|
|
2414
|
+
z.string(),
|
|
2415
|
+
z.null()
|
|
2416
|
+
])
|
|
2252
2417
|
});
|
|
2253
2418
|
var zJobActivationResult = z.object({
|
|
2254
2419
|
jobs: z.array(zActivatedJobResult).register(z.globalRegistry, {
|
|
@@ -2761,7 +2926,11 @@ var zIncidentResolutionRequest = z.object({
|
|
|
2761
2926
|
});
|
|
2762
2927
|
var zJobUpdateRequest = z.object({
|
|
2763
2928
|
changeset: zJobChangeset,
|
|
2764
|
-
operationReference: z.optional(zOperationReference)
|
|
2929
|
+
operationReference: z.optional(zOperationReference),
|
|
2930
|
+
leaseToken: z.optional(z.union([
|
|
2931
|
+
z.string(),
|
|
2932
|
+
z.null()
|
|
2933
|
+
]))
|
|
2765
2934
|
});
|
|
2766
2935
|
var zAgentInstanceKey = zLongKey;
|
|
2767
2936
|
var zAgentInstanceResult = z.object({
|
|
@@ -2819,8 +2988,8 @@ var zAgentInstanceHistoryItemResult = z.object({
|
|
|
2819
2988
|
jobLease: z.string().register(z.globalRegistry, {
|
|
2820
2989
|
description: "The lease token of the activation that produced this item."
|
|
2821
2990
|
}),
|
|
2822
|
-
|
|
2823
|
-
|
|
2991
|
+
loopIteration: z.union([
|
|
2992
|
+
zLoopIterationId,
|
|
2824
2993
|
z.null()
|
|
2825
2994
|
]),
|
|
2826
2995
|
role: zAgentInstanceHistoryRoleEnum,
|
|
@@ -2830,7 +2999,10 @@ var zAgentInstanceHistoryItemResult = z.object({
|
|
|
2830
2999
|
toolCalls: z.array(zAgentInstanceToolCall).register(z.globalRegistry, {
|
|
2831
3000
|
description: "Tool calls for this item. Empty for USER items and ASSISTANT items with no tool dispatches.\nASSISTANT items: dispatched tool calls with arguments populated.\nTOOL_RESULT items: single-entry array referencing the originating tool call (arguments null).\n"
|
|
2832
3001
|
}),
|
|
2833
|
-
metrics:
|
|
3002
|
+
metrics: z.union([
|
|
3003
|
+
zAgentInstanceHistoryItemMetrics,
|
|
3004
|
+
z.null()
|
|
3005
|
+
]),
|
|
2834
3006
|
commitStatus: zAgentInstanceHistoryCommitStatusEnum,
|
|
2835
3007
|
producedAt: z.iso.datetime().register(z.globalRegistry, {
|
|
2836
3008
|
description: "The connector-side timestamp of when this message was produced."
|
|
@@ -3467,6 +3639,12 @@ var zProcessDefinitionFilter = z.object({
|
|
|
3467
3639
|
processDefinitionKey: z.optional(zProcessDefinitionKey),
|
|
3468
3640
|
hasStartForm: z.optional(z.boolean().register(z.globalRegistry, {
|
|
3469
3641
|
description: "Indicates whether the start event of the process has an associated Form Key."
|
|
3642
|
+
})),
|
|
3643
|
+
state: z.optional(z.enum([
|
|
3644
|
+
"ACTIVE",
|
|
3645
|
+
"DELETED"
|
|
3646
|
+
]).register(z.globalRegistry, {
|
|
3647
|
+
description: "Filter by the process definition's state.\nWhen not set, process definitions in any state are returned.\nSet to `ACTIVE` to exclude deleted definitions (recommended for most use cases).\nSet to `DELETED` to return only definitions that have been deleted but are still\nretained in secondary storage.\n"
|
|
3470
3648
|
}))
|
|
3471
3649
|
}).register(z.globalRegistry, {
|
|
3472
3650
|
description: "Process definition search filter."
|
|
@@ -3491,6 +3669,12 @@ var zProcessDefinitionResult = z.object({
|
|
|
3491
3669
|
processDefinitionKey: zProcessDefinitionKey,
|
|
3492
3670
|
hasStartForm: z.boolean().register(z.globalRegistry, {
|
|
3493
3671
|
description: "Indicates whether the start event of the process has an associated Form Key."
|
|
3672
|
+
}),
|
|
3673
|
+
state: z.enum([
|
|
3674
|
+
"ACTIVE",
|
|
3675
|
+
"DELETED"
|
|
3676
|
+
]).register(z.globalRegistry, {
|
|
3677
|
+
description: "The state of this process definition."
|
|
3494
3678
|
})
|
|
3495
3679
|
});
|
|
3496
3680
|
var zProcessElementStatisticsResult = z.object({
|
|
@@ -3517,6 +3701,18 @@ var zProcessDefinitionElementStatisticsQueryResult = z.object({
|
|
|
3517
3701
|
}).register(z.globalRegistry, {
|
|
3518
3702
|
description: "Process definition element statistics query response."
|
|
3519
3703
|
});
|
|
3704
|
+
var zProcessDefinitionVariableNameFilter = z.object({
|
|
3705
|
+
name: z.optional(zStringFilterProperty)
|
|
3706
|
+
}).register(z.globalRegistry, {
|
|
3707
|
+
description: "Process definition variable name filter request."
|
|
3708
|
+
});
|
|
3709
|
+
var zProcessDefinitionVariableNameSearchResult = z.object({
|
|
3710
|
+
name: z.string().register(z.globalRegistry, {
|
|
3711
|
+
description: "The variable name."
|
|
3712
|
+
})
|
|
3713
|
+
}).register(z.globalRegistry, {
|
|
3714
|
+
description: "Process definition variable name search response item."
|
|
3715
|
+
});
|
|
3520
3716
|
var zProcessDefinitionMessageSubscriptionStatisticsResult = z.object({
|
|
3521
3717
|
processDefinitionId: zProcessDefinitionId,
|
|
3522
3718
|
tenantId: zTenantId,
|
|
@@ -3676,6 +3872,18 @@ var zDeleteProcessInstanceRequest = z.union([
|
|
|
3676
3872
|
}),
|
|
3677
3873
|
z.null()
|
|
3678
3874
|
]);
|
|
3875
|
+
var zSuspendProcessInstanceRequest = z.union([
|
|
3876
|
+
z.object({
|
|
3877
|
+
operationReference: z.optional(zOperationReference)
|
|
3878
|
+
}),
|
|
3879
|
+
z.null()
|
|
3880
|
+
]);
|
|
3881
|
+
var zResumeProcessInstanceRequest = z.union([
|
|
3882
|
+
z.object({
|
|
3883
|
+
operationReference: z.optional(zOperationReference)
|
|
3884
|
+
}),
|
|
3885
|
+
z.null()
|
|
3886
|
+
]);
|
|
3679
3887
|
var zProcessInstanceCallHierarchyEntry = z.object({
|
|
3680
3888
|
processInstanceKey: zProcessInstanceKey,
|
|
3681
3889
|
processDefinitionKey: zProcessDefinitionKey,
|
|
@@ -3751,6 +3959,11 @@ var zProcessInstanceMigrationInstruction = z.object({
|
|
|
3751
3959
|
}).register(z.globalRegistry, {
|
|
3752
3960
|
description: "The migration instructions describe how to migrate a process instance from one process definition to another.\n"
|
|
3753
3961
|
});
|
|
3962
|
+
var zProcessInstanceBusinessIdAssignmentInstruction = z.object({
|
|
3963
|
+
businessId: zBusinessId
|
|
3964
|
+
}).register(z.globalRegistry, {
|
|
3965
|
+
description: "The instruction describing the business id to assign to a running process instance.\n"
|
|
3966
|
+
});
|
|
3754
3967
|
var zModifyProcessInstanceVariableInstruction = z.object({
|
|
3755
3968
|
variables: z.record(z.string(), z.unknown()).register(z.globalRegistry, {
|
|
3756
3969
|
description: "JSON document that will instantiate the variables at the scope defined by the scopeId.\nIt must be a JSON object, as variables will be mapped in a key-value fashion.\n"
|
|
@@ -3866,6 +4079,7 @@ var zProcessInstanceModificationInstruction = z.object({
|
|
|
3866
4079
|
var zProcessInstanceStateEnum = z.enum([
|
|
3867
4080
|
"ACTIVE",
|
|
3868
4081
|
"COMPLETED",
|
|
4082
|
+
"SUSPENDED",
|
|
3869
4083
|
"TERMINATED"
|
|
3870
4084
|
]).register(z.globalRegistry, {
|
|
3871
4085
|
description: "Process instance states"
|
|
@@ -3891,6 +4105,10 @@ var zProcessInstanceResult = z.object({
|
|
|
3891
4105
|
z.null()
|
|
3892
4106
|
]),
|
|
3893
4107
|
state: zProcessInstanceStateEnum,
|
|
4108
|
+
suspendedDate: z.union([
|
|
4109
|
+
z.iso.datetime(),
|
|
4110
|
+
z.null()
|
|
4111
|
+
]),
|
|
3894
4112
|
hasIncident: z.boolean().register(z.globalRegistry, {
|
|
3895
4113
|
description: "Whether this process instance has a related incident or not."
|
|
3896
4114
|
}),
|
|
@@ -4054,6 +4272,11 @@ var zSearchQueryPageRequest = z.union([
|
|
|
4054
4272
|
var zSearchQueryRequest = z.object({
|
|
4055
4273
|
page: z.optional(zSearchQueryPageRequest)
|
|
4056
4274
|
});
|
|
4275
|
+
var zProcessDefinitionVariableNameSearchQuery = zSearchQueryRequest.and(z.object({
|
|
4276
|
+
filter: z.optional(zProcessDefinitionVariableNameFilter)
|
|
4277
|
+
}).register(z.globalRegistry, {
|
|
4278
|
+
description: "Process definition variable name search query request."
|
|
4279
|
+
}));
|
|
4057
4280
|
var zSortOrderEnum = z.enum([
|
|
4058
4281
|
"ASC",
|
|
4059
4282
|
"DESC"
|
|
@@ -4081,7 +4304,7 @@ var zAgentInstanceHistorySearchQuerySortRequest = z.object({
|
|
|
4081
4304
|
field: z.enum([
|
|
4082
4305
|
"producedAt",
|
|
4083
4306
|
"historyItemKey",
|
|
4084
|
-
"
|
|
4307
|
+
"loopIteration"
|
|
4085
4308
|
]).register(z.globalRegistry, {
|
|
4086
4309
|
description: "The field to sort by."
|
|
4087
4310
|
}),
|
|
@@ -4541,6 +4764,7 @@ var zProcessInstanceSearchQuerySortRequest = z.object({
|
|
|
4541
4764
|
"parentElementInstanceKey",
|
|
4542
4765
|
"startDate",
|
|
4543
4766
|
"endDate",
|
|
4767
|
+
"suspendedDate",
|
|
4544
4768
|
"state",
|
|
4545
4769
|
"hasIncident",
|
|
4546
4770
|
"tenantId",
|
|
@@ -4810,6 +5034,13 @@ var zProcessDefinitionSearchQueryResult = zSearchQueryResponse.and(z.object({
|
|
|
4810
5034
|
description: "The matching process definitions."
|
|
4811
5035
|
})
|
|
4812
5036
|
}));
|
|
5037
|
+
var zProcessDefinitionVariableNameSearchQueryResult = zSearchQueryResponse.and(z.object({
|
|
5038
|
+
items: z.array(zProcessDefinitionVariableNameSearchResult).register(z.globalRegistry, {
|
|
5039
|
+
description: "The matching variable names."
|
|
5040
|
+
})
|
|
5041
|
+
}).register(z.globalRegistry, {
|
|
5042
|
+
description: "Process definition variable name search query response."
|
|
5043
|
+
}));
|
|
4813
5044
|
var zProcessDefinitionMessageSubscriptionStatisticsQueryResult = zSearchQueryResponse.and(z.object({
|
|
4814
5045
|
items: z.array(zProcessDefinitionMessageSubscriptionStatisticsResult).register(z.globalRegistry, {
|
|
4815
5046
|
description: "The matching process definition message subscription statistics."
|
|
@@ -4859,6 +5090,47 @@ var zRoleMappingRuleSearchResult = zSearchQueryResponse.and(z.object({
|
|
|
4859
5090
|
description: "The matching mapping rules."
|
|
4860
5091
|
})
|
|
4861
5092
|
}));
|
|
5093
|
+
var zSecretResolveRequest = z.object({
|
|
5094
|
+
references: z.array(z.string().max(256).register(z.globalRegistry, {
|
|
5095
|
+
description: "A secret reference of the form `camunda.secrets.<name>`."
|
|
5096
|
+
})).max(20).register(z.globalRegistry, {
|
|
5097
|
+
description: "The secret references to resolve, each of the form `camunda.secrets.<name>`.\nDuplicate references are deduplicated by the server and resolved once.\nAt most 20 references may be requested in a single batch.\n"
|
|
5098
|
+
})
|
|
5099
|
+
});
|
|
5100
|
+
var zResolvedSecret = z.object({
|
|
5101
|
+
reference: z.string().register(z.globalRegistry, {
|
|
5102
|
+
description: "The resolved secret reference of the form `camunda.secrets.<name>`."
|
|
5103
|
+
}),
|
|
5104
|
+
value: z.string().register(z.globalRegistry, {
|
|
5105
|
+
description: "The resolved secret value."
|
|
5106
|
+
})
|
|
5107
|
+
});
|
|
5108
|
+
var zSecretErrorCode = z.enum([
|
|
5109
|
+
"NOT_FOUND",
|
|
5110
|
+
"ACCESS_DENIED",
|
|
5111
|
+
"INVALID_REFERENCE"
|
|
5112
|
+
]).register(z.globalRegistry, {
|
|
5113
|
+
description: "The typed reason a reference could not be resolved.\n\n- `NOT_FOUND`: no secret exists for the reference.\n- `ACCESS_DENIED`: the caller lacks `SECRET:REVEAL` on the reference.\n- `INVALID_REFERENCE`: the reference is malformed.\n"
|
|
5114
|
+
});
|
|
5115
|
+
var zSecretResolutionError = z.object({
|
|
5116
|
+
reference: z.string().register(z.globalRegistry, {
|
|
5117
|
+
description: "The secret reference that could not be resolved."
|
|
5118
|
+
}),
|
|
5119
|
+
code: zSecretErrorCode,
|
|
5120
|
+
message: z.string().register(z.globalRegistry, {
|
|
5121
|
+
description: "A human-readable description of the failure. Never contains the secret value;\nonly error metadata (codes, names) is included.\n"
|
|
5122
|
+
})
|
|
5123
|
+
});
|
|
5124
|
+
var zSecretResolveResult = z.object({
|
|
5125
|
+
resolved: z.array(zResolvedSecret).register(z.globalRegistry, {
|
|
5126
|
+
description: "The references that were successfully resolved."
|
|
5127
|
+
}),
|
|
5128
|
+
errors: z.array(zSecretResolutionError).register(z.globalRegistry, {
|
|
5129
|
+
description: "The references that could not be resolved, each with a typed error code."
|
|
5130
|
+
})
|
|
5131
|
+
}).register(z.globalRegistry, {
|
|
5132
|
+
description: "The per-reference outcome of a resolve request."
|
|
5133
|
+
});
|
|
4862
5134
|
var zSignalBroadcastRequest = z.object({
|
|
4863
5135
|
signalName: z.string().register(z.globalRegistry, {
|
|
4864
5136
|
description: "The name of the signal to broadcast."
|
|
@@ -5629,6 +5901,11 @@ var zClusterVariableScopeFilterProperty = z.union([
|
|
|
5629
5901
|
zClusterVariableScopeExactMatch,
|
|
5630
5902
|
zAdvancedClusterVariableScopeFilter
|
|
5631
5903
|
]);
|
|
5904
|
+
var zClusterVariableKindExactMatch = zClusterVariableKindEnum;
|
|
5905
|
+
var zClusterVariableKindFilterProperty = z.union([
|
|
5906
|
+
zClusterVariableKindExactMatch,
|
|
5907
|
+
zAdvancedClusterVariableKindFilter
|
|
5908
|
+
]);
|
|
5632
5909
|
var zClusterVariableSearchQueryFilterRequest = z.object({
|
|
5633
5910
|
name: z.optional(zStringFilterProperty),
|
|
5634
5911
|
value: z.optional(zStringFilterProperty),
|
|
@@ -5636,7 +5913,11 @@ var zClusterVariableSearchQueryFilterRequest = z.object({
|
|
|
5636
5913
|
tenantId: z.optional(zStringFilterProperty),
|
|
5637
5914
|
isTruncated: z.optional(z.boolean().register(z.globalRegistry, {
|
|
5638
5915
|
description: "Filter cluster variables by truncation status of their stored values. When true, returns only variables whose stored values are truncated (i.e., the value exceeds the storage size limit and is truncated in storage). When false, returns only variables with non-truncated stored values. This filter is based on the underlying storage characteristic, not the response format.\n"
|
|
5639
|
-
}))
|
|
5916
|
+
})),
|
|
5917
|
+
metadata: z.optional(z.record(z.string(), zAdvancedMetadataValueFilter).register(z.globalRegistry, {
|
|
5918
|
+
description: "Filter by metadata entries. A map of metadata key to an advanced filter on that key's value. Metadata values are strings or numbers."
|
|
5919
|
+
})),
|
|
5920
|
+
kind: z.optional(zClusterVariableKindFilterProperty)
|
|
5640
5921
|
}).register(z.globalRegistry, {
|
|
5641
5922
|
description: "Cluster variable filter request."
|
|
5642
5923
|
});
|
|
@@ -6040,7 +6321,7 @@ var zAgentInstanceHistoryFilter = z.object({
|
|
|
6040
6321
|
role: z.optional(zAgentInstanceHistoryRoleFilterProperty),
|
|
6041
6322
|
elementInstanceKey: z.optional(zElementInstanceKeyFilterProperty),
|
|
6042
6323
|
jobKey: z.optional(zJobKeyFilterProperty),
|
|
6043
|
-
|
|
6324
|
+
loopIteration: z.optional(zIntegerFilterProperty),
|
|
6044
6325
|
commitStatus: z.optional(zAgentInstanceHistoryCommitStatusFilterProperty),
|
|
6045
6326
|
producedAt: z.optional(zDateTimeFilterProperty)
|
|
6046
6327
|
}).register(z.globalRegistry, {
|
|
@@ -6236,6 +6517,7 @@ var zBaseProcessInstanceFilterFields = z.object({
|
|
|
6236
6517
|
hasIncident: z.optional(z.boolean().register(z.globalRegistry, {
|
|
6237
6518
|
description: "Whether this process instance has a related incident or not."
|
|
6238
6519
|
})),
|
|
6520
|
+
suspendedDate: z.optional(zDateTimeFilterProperty),
|
|
6239
6521
|
tenantId: z.optional(zStringFilterProperty),
|
|
6240
6522
|
variables: z.optional(z.array(zVariableValueFilterProperty).register(z.globalRegistry, {
|
|
6241
6523
|
description: "The process instance variables."
|
|
@@ -6316,6 +6598,18 @@ var zProcessInstanceModificationBatchOperationRequest = z.object({
|
|
|
6316
6598
|
}).register(z.globalRegistry, {
|
|
6317
6599
|
description: "The process instance filter to define on which process instances tokens should be moved,\nand new element instances should be activated or terminated.\n"
|
|
6318
6600
|
});
|
|
6601
|
+
var zProcessInstanceSuspensionBatchOperationRequest = z.object({
|
|
6602
|
+
filter: zProcessInstanceFilter,
|
|
6603
|
+
operationReference: z.optional(zOperationReference)
|
|
6604
|
+
}).register(z.globalRegistry, {
|
|
6605
|
+
description: "The process instance filter that defines which process instances should be suspended."
|
|
6606
|
+
});
|
|
6607
|
+
var zProcessInstanceResumptionBatchOperationRequest = z.object({
|
|
6608
|
+
filter: zProcessInstanceFilter,
|
|
6609
|
+
operationReference: z.optional(zOperationReference)
|
|
6610
|
+
}).register(z.globalRegistry, {
|
|
6611
|
+
description: "The process instance filter that defines which process instances should be resumed."
|
|
6612
|
+
});
|
|
6319
6613
|
var zProcessInstanceSearchQuery = zSearchQueryRequest.and(z.object({
|
|
6320
6614
|
sort: z.optional(z.array(zProcessInstanceSearchQuerySortRequest).register(z.globalRegistry, {
|
|
6321
6615
|
description: "Sort field criteria."
|
|
@@ -7283,6 +7577,14 @@ var zGetProcessDefinitionStatisticsData = z.object({
|
|
|
7283
7577
|
query: z.optional(z.never())
|
|
7284
7578
|
});
|
|
7285
7579
|
var zGetProcessDefinitionStatisticsResponse = zProcessDefinitionElementStatisticsQueryResult;
|
|
7580
|
+
var zSearchProcessDefinitionVariableNamesData = z.object({
|
|
7581
|
+
body: z.optional(zProcessDefinitionVariableNameSearchQuery),
|
|
7582
|
+
path: z.object({
|
|
7583
|
+
processDefinitionKey: zProcessDefinitionKey
|
|
7584
|
+
}),
|
|
7585
|
+
query: z.optional(z.never())
|
|
7586
|
+
});
|
|
7587
|
+
var zSearchProcessDefinitionVariableNamesResponse = zProcessDefinitionVariableNameSearchQueryResult;
|
|
7286
7588
|
var zGetProcessDefinitionXmlData = z.object({
|
|
7287
7589
|
body: z.optional(z.never()),
|
|
7288
7590
|
path: z.object({
|
|
@@ -7335,12 +7637,24 @@ var zModifyProcessInstancesBatchOperationData = z.object({
|
|
|
7335
7637
|
query: z.optional(z.never())
|
|
7336
7638
|
});
|
|
7337
7639
|
var zModifyProcessInstancesBatchOperationResponse = zBatchOperationCreatedResult;
|
|
7640
|
+
var zResumeProcessInstancesBatchOperationData = z.object({
|
|
7641
|
+
body: zProcessInstanceResumptionBatchOperationRequest,
|
|
7642
|
+
path: z.optional(z.never()),
|
|
7643
|
+
query: z.optional(z.never())
|
|
7644
|
+
});
|
|
7645
|
+
var zResumeProcessInstancesBatchOperationResponse = zBatchOperationCreatedResult;
|
|
7338
7646
|
var zSearchProcessInstancesData = z.object({
|
|
7339
7647
|
body: z.optional(zProcessInstanceSearchQuery),
|
|
7340
7648
|
path: z.optional(z.never()),
|
|
7341
7649
|
query: z.optional(z.never())
|
|
7342
7650
|
});
|
|
7343
7651
|
var zSearchProcessInstancesResponse = zProcessInstanceSearchQueryResult;
|
|
7652
|
+
var zSuspendProcessInstancesBatchOperationData = z.object({
|
|
7653
|
+
body: zProcessInstanceSuspensionBatchOperationRequest,
|
|
7654
|
+
path: z.optional(z.never()),
|
|
7655
|
+
query: z.optional(z.never())
|
|
7656
|
+
});
|
|
7657
|
+
var zSuspendProcessInstancesBatchOperationResponse = zBatchOperationCreatedResult;
|
|
7344
7658
|
var zGetProcessInstanceData = z.object({
|
|
7345
7659
|
body: z.optional(z.never()),
|
|
7346
7660
|
path: z.object({
|
|
@@ -7349,6 +7663,16 @@ var zGetProcessInstanceData = z.object({
|
|
|
7349
7663
|
query: z.optional(z.never())
|
|
7350
7664
|
});
|
|
7351
7665
|
var zGetProcessInstanceResponse = zProcessInstanceResult;
|
|
7666
|
+
var zAssignProcessInstanceBusinessIdData = z.object({
|
|
7667
|
+
body: zProcessInstanceBusinessIdAssignmentInstruction,
|
|
7668
|
+
path: z.object({
|
|
7669
|
+
processInstanceKey: zProcessInstanceKey
|
|
7670
|
+
}),
|
|
7671
|
+
query: z.optional(z.never())
|
|
7672
|
+
});
|
|
7673
|
+
var zAssignProcessInstanceBusinessIdResponse = z.void().register(z.globalRegistry, {
|
|
7674
|
+
description: "The business id is assigned to the process instance."
|
|
7675
|
+
});
|
|
7352
7676
|
var zGetProcessInstanceCallHierarchyData = z.object({
|
|
7353
7677
|
body: z.optional(z.never()),
|
|
7354
7678
|
path: z.object({
|
|
@@ -7415,6 +7739,16 @@ var zModifyProcessInstanceData = z.object({
|
|
|
7415
7739
|
var zModifyProcessInstanceResponse = z.void().register(z.globalRegistry, {
|
|
7416
7740
|
description: "The process instance is modified."
|
|
7417
7741
|
});
|
|
7742
|
+
var zResumeProcessInstanceData = z.object({
|
|
7743
|
+
body: z.optional(zResumeProcessInstanceRequest),
|
|
7744
|
+
path: z.object({
|
|
7745
|
+
processInstanceKey: zProcessInstanceKey
|
|
7746
|
+
}),
|
|
7747
|
+
query: z.optional(z.never())
|
|
7748
|
+
});
|
|
7749
|
+
var zResumeProcessInstanceResponse = z.void().register(z.globalRegistry, {
|
|
7750
|
+
description: "The process instance is resumed."
|
|
7751
|
+
});
|
|
7418
7752
|
var zGetProcessInstanceSequenceFlowsData = z.object({
|
|
7419
7753
|
body: z.optional(z.never()),
|
|
7420
7754
|
path: z.object({
|
|
@@ -7439,6 +7773,16 @@ var zGetProcessInstanceWaitStateStatisticsData = z.object({
|
|
|
7439
7773
|
query: z.optional(z.never())
|
|
7440
7774
|
});
|
|
7441
7775
|
var zGetProcessInstanceWaitStateStatisticsResponse = zProcessInstanceWaitStateStatisticsQueryResult;
|
|
7776
|
+
var zSuspendProcessInstanceData = z.object({
|
|
7777
|
+
body: z.optional(zSuspendProcessInstanceRequest),
|
|
7778
|
+
path: z.object({
|
|
7779
|
+
processInstanceKey: zProcessInstanceKey
|
|
7780
|
+
}),
|
|
7781
|
+
query: z.optional(z.never())
|
|
7782
|
+
});
|
|
7783
|
+
var zSuspendProcessInstanceResponse = z.void().register(z.globalRegistry, {
|
|
7784
|
+
description: "The process instance is suspended."
|
|
7785
|
+
});
|
|
7442
7786
|
var zSearchResourcesData = z.object({
|
|
7443
7787
|
body: z.optional(zResourceSearchQuery),
|
|
7444
7788
|
path: z.optional(z.never()),
|
|
@@ -7639,6 +7983,12 @@ var zAssignRoleToUserData = z.object({
|
|
|
7639
7983
|
var zAssignRoleToUserResponse = z.void().register(z.globalRegistry, {
|
|
7640
7984
|
description: "The role was assigned successfully to the user."
|
|
7641
7985
|
});
|
|
7986
|
+
var zResolveSecretsData = z.object({
|
|
7987
|
+
body: zSecretResolveRequest,
|
|
7988
|
+
path: z.optional(z.never()),
|
|
7989
|
+
query: z.optional(z.never())
|
|
7990
|
+
});
|
|
7991
|
+
var zResolveSecretsResponse = zSecretResolveResult;
|
|
7642
7992
|
var zCreateAdminUserData = z.object({
|
|
7643
7993
|
body: zUserRequest,
|
|
7644
7994
|
path: z.optional(z.never()),
|
|
@@ -7876,6 +8226,28 @@ var zGetTopologyData = z.object({
|
|
|
7876
8226
|
query: z.optional(z.never())
|
|
7877
8227
|
});
|
|
7878
8228
|
var zGetTopologyResponse = zTopologyResponse;
|
|
8229
|
+
var zChangeClusterModeData = z.object({
|
|
8230
|
+
body: z.optional(z.never()),
|
|
8231
|
+
path: z.optional(z.never()),
|
|
8232
|
+
query: z.object({
|
|
8233
|
+
mode: z.enum([
|
|
8234
|
+
"PROCESSING",
|
|
8235
|
+
"RECOVERING"
|
|
8236
|
+
]).register(z.globalRegistry, {
|
|
8237
|
+
description: "The target cluster mode."
|
|
8238
|
+
}),
|
|
8239
|
+
dryRun: z.optional(z.boolean().register(z.globalRegistry, {
|
|
8240
|
+
description: "If true, the requested change is only validated and the resulting plan is returned, without applying it to the cluster."
|
|
8241
|
+
})).default(false)
|
|
8242
|
+
})
|
|
8243
|
+
});
|
|
8244
|
+
var zChangeClusterModeResponse = zClusterModeChangeResponse;
|
|
8245
|
+
var zRestoreData = z.object({
|
|
8246
|
+
body: zRestoreRequest,
|
|
8247
|
+
path: z.optional(z.never()),
|
|
8248
|
+
query: z.optional(z.never())
|
|
8249
|
+
});
|
|
8250
|
+
var zRestoreResponse = zClusterModeChangeResponse;
|
|
7879
8251
|
var zCreateUserData = z.object({
|
|
7880
8252
|
body: zUserRequest,
|
|
7881
8253
|
path: z.optional(z.never()),
|
|
@@ -7977,15 +8349,7 @@ var zCompleteUserTaskResponse = z.void().register(z.globalRegistry, {
|
|
|
7977
8349
|
description: "The user task was completed successfully."
|
|
7978
8350
|
});
|
|
7979
8351
|
var zSearchUserTaskEffectiveVariablesData = z.object({
|
|
7980
|
-
body: z.optional(
|
|
7981
|
-
page: z.optional(zOffsetPagination),
|
|
7982
|
-
sort: z.optional(z.array(zUserTaskVariableSearchQuerySortRequest).register(z.globalRegistry, {
|
|
7983
|
-
description: "Sort field criteria."
|
|
7984
|
-
})),
|
|
7985
|
-
filter: z.optional(zUserTaskVariableFilter)
|
|
7986
|
-
}).register(z.globalRegistry, {
|
|
7987
|
-
description: "User task effective variable search query request. Uses offset-based pagination only.\n"
|
|
7988
|
-
})),
|
|
8352
|
+
body: z.optional(zUserTaskEffectiveVariableSearchQueryRequest),
|
|
7989
8353
|
path: z.object({
|
|
7990
8354
|
userTaskKey: zUserTaskKey
|
|
7991
8355
|
}),
|
|
@@ -8059,6 +8423,7 @@ export {
|
|
|
8059
8423
|
zAdvancedBatchOperationStateFilter,
|
|
8060
8424
|
zAdvancedBatchOperationTypeFilter,
|
|
8061
8425
|
zAdvancedCategoryFilter,
|
|
8426
|
+
zAdvancedClusterVariableKindFilter,
|
|
8062
8427
|
zAdvancedClusterVariableScopeFilter,
|
|
8063
8428
|
zAdvancedDateTimeFilter,
|
|
8064
8429
|
zAdvancedDecisionDefinitionKeyFilter,
|
|
@@ -8084,6 +8449,7 @@ export {
|
|
|
8084
8449
|
zAdvancedMessageSubscriptionKeyFilter,
|
|
8085
8450
|
zAdvancedMessageSubscriptionStateFilter,
|
|
8086
8451
|
zAdvancedMessageSubscriptionTypeFilter,
|
|
8452
|
+
zAdvancedMetadataValueFilter,
|
|
8087
8453
|
zAdvancedOperationTypeFilter,
|
|
8088
8454
|
zAdvancedProcessDefinitionIdFilter,
|
|
8089
8455
|
zAdvancedProcessDefinitionKeyFilter,
|
|
@@ -8151,6 +8517,8 @@ export {
|
|
|
8151
8517
|
zAssignMappingRuleToGroupResponse,
|
|
8152
8518
|
zAssignMappingRuleToTenantData,
|
|
8153
8519
|
zAssignMappingRuleToTenantResponse,
|
|
8520
|
+
zAssignProcessInstanceBusinessIdData,
|
|
8521
|
+
zAssignProcessInstanceBusinessIdResponse,
|
|
8154
8522
|
zAssignRoleToClientData,
|
|
8155
8523
|
zAssignRoleToClientResponse,
|
|
8156
8524
|
zAssignRoleToGroupData,
|
|
@@ -8238,11 +8606,18 @@ export {
|
|
|
8238
8606
|
zCancelProcessInstancesBatchOperationResponse,
|
|
8239
8607
|
zCategoryExactMatch,
|
|
8240
8608
|
zCategoryFilterProperty,
|
|
8609
|
+
zChangeClusterModeData,
|
|
8610
|
+
zChangeClusterModeResponse,
|
|
8241
8611
|
zChangeset,
|
|
8242
8612
|
zClientId,
|
|
8243
8613
|
zClockPinRequest,
|
|
8244
8614
|
zCloudConfigurationResponse,
|
|
8245
8615
|
zCloudStage,
|
|
8616
|
+
zClusterModeChangeOperation,
|
|
8617
|
+
zClusterModeChangeResponse,
|
|
8618
|
+
zClusterVariableKindEnum,
|
|
8619
|
+
zClusterVariableKindExactMatch,
|
|
8620
|
+
zClusterVariableKindFilterProperty,
|
|
8246
8621
|
zClusterVariableName,
|
|
8247
8622
|
zClusterVariableResult,
|
|
8248
8623
|
zClusterVariableResultBase,
|
|
@@ -8611,7 +8986,6 @@ export {
|
|
|
8611
8986
|
zIncidentStateFilterProperty,
|
|
8612
8987
|
zInferredAncestorKeyInstruction,
|
|
8613
8988
|
zIntegerFilterProperty,
|
|
8614
|
-
zIterationId,
|
|
8615
8989
|
zJobActivationRequest,
|
|
8616
8990
|
zJobActivationResult,
|
|
8617
8991
|
zJobBatchUpdateRequest,
|
|
@@ -8664,6 +9038,7 @@ export {
|
|
|
8664
9038
|
zLikeFilter,
|
|
8665
9039
|
zLimitPagination,
|
|
8666
9040
|
zLongKey,
|
|
9041
|
+
zLoopIterationId,
|
|
8667
9042
|
zMappingRuleCreateRequest,
|
|
8668
9043
|
zMappingRuleCreateResult,
|
|
8669
9044
|
zMappingRuleCreateUpdateRequest,
|
|
@@ -8743,7 +9118,12 @@ export {
|
|
|
8743
9118
|
zProcessDefinitionSearchQueryResult,
|
|
8744
9119
|
zProcessDefinitionSearchQuerySortRequest,
|
|
8745
9120
|
zProcessDefinitionStatisticsFilter,
|
|
9121
|
+
zProcessDefinitionVariableNameFilter,
|
|
9122
|
+
zProcessDefinitionVariableNameSearchQuery,
|
|
9123
|
+
zProcessDefinitionVariableNameSearchQueryResult,
|
|
9124
|
+
zProcessDefinitionVariableNameSearchResult,
|
|
8746
9125
|
zProcessElementStatisticsResult,
|
|
9126
|
+
zProcessInstanceBusinessIdAssignmentInstruction,
|
|
8747
9127
|
zProcessInstanceCallHierarchyEntry,
|
|
8748
9128
|
zProcessInstanceCancellationBatchOperationRequest,
|
|
8749
9129
|
zProcessInstanceCreationInstruction,
|
|
@@ -8773,6 +9153,7 @@ export {
|
|
|
8773
9153
|
zProcessInstanceModificationTerminateInstruction,
|
|
8774
9154
|
zProcessInstanceReference,
|
|
8775
9155
|
zProcessInstanceResult,
|
|
9156
|
+
zProcessInstanceResumptionBatchOperationRequest,
|
|
8776
9157
|
zProcessInstanceSearchQuery,
|
|
8777
9158
|
zProcessInstanceSearchQueryResult,
|
|
8778
9159
|
zProcessInstanceSearchQuerySortRequest,
|
|
@@ -8781,6 +9162,7 @@ export {
|
|
|
8781
9162
|
zProcessInstanceStateEnum,
|
|
8782
9163
|
zProcessInstanceStateExactMatch,
|
|
8783
9164
|
zProcessInstanceStateFilterProperty,
|
|
9165
|
+
zProcessInstanceSuspensionBatchOperationRequest,
|
|
8784
9166
|
zProcessInstanceWaitStateStatisticsQueryResult,
|
|
8785
9167
|
zProcessInstanceWaitStateStatisticsResult,
|
|
8786
9168
|
zPublishMessageData,
|
|
@@ -8793,6 +9175,9 @@ export {
|
|
|
8793
9175
|
zResolveIncidentsBatchOperationResponse,
|
|
8794
9176
|
zResolveProcessInstanceIncidentsData,
|
|
8795
9177
|
zResolveProcessInstanceIncidentsResponse,
|
|
9178
|
+
zResolveSecretsData,
|
|
9179
|
+
zResolveSecretsResponse,
|
|
9180
|
+
zResolvedSecret,
|
|
8796
9181
|
zResourceFilter,
|
|
8797
9182
|
zResourceKey,
|
|
8798
9183
|
zResourceKeyExactMatch,
|
|
@@ -8802,8 +9187,16 @@ export {
|
|
|
8802
9187
|
zResourceSearchQueryResult,
|
|
8803
9188
|
zResourceSearchQuerySortRequest,
|
|
8804
9189
|
zResourceTypeEnum,
|
|
9190
|
+
zRestoreData,
|
|
9191
|
+
zRestoreRequest,
|
|
9192
|
+
zRestoreResponse,
|
|
8805
9193
|
zResumeBatchOperationData,
|
|
8806
9194
|
zResumeBatchOperationResponse,
|
|
9195
|
+
zResumeProcessInstanceData,
|
|
9196
|
+
zResumeProcessInstanceRequest,
|
|
9197
|
+
zResumeProcessInstanceResponse,
|
|
9198
|
+
zResumeProcessInstancesBatchOperationData,
|
|
9199
|
+
zResumeProcessInstancesBatchOperationResponse,
|
|
8807
9200
|
zRoleClientResult,
|
|
8808
9201
|
zRoleClientSearchQueryRequest,
|
|
8809
9202
|
zRoleClientSearchQuerySortRequest,
|
|
@@ -8886,6 +9279,8 @@ export {
|
|
|
8886
9279
|
zSearchMappingRulesForTenantResponse,
|
|
8887
9280
|
zSearchMessageSubscriptionsData,
|
|
8888
9281
|
zSearchMessageSubscriptionsResponse,
|
|
9282
|
+
zSearchProcessDefinitionVariableNamesData,
|
|
9283
|
+
zSearchProcessDefinitionVariableNamesResponse,
|
|
8889
9284
|
zSearchProcessDefinitionsData,
|
|
8890
9285
|
zSearchProcessDefinitionsResponse,
|
|
8891
9286
|
zSearchProcessInstanceIncidentsData,
|
|
@@ -8924,6 +9319,10 @@ export {
|
|
|
8924
9319
|
zSearchUsersResponse,
|
|
8925
9320
|
zSearchVariablesData,
|
|
8926
9321
|
zSearchVariablesResponse,
|
|
9322
|
+
zSecretErrorCode,
|
|
9323
|
+
zSecretResolutionError,
|
|
9324
|
+
zSecretResolveRequest,
|
|
9325
|
+
zSecretResolveResult,
|
|
8927
9326
|
zSetVariableRequest,
|
|
8928
9327
|
zSignalBroadcastRequest,
|
|
8929
9328
|
zSignalBroadcastResult,
|
|
@@ -8938,6 +9337,11 @@ export {
|
|
|
8938
9337
|
zStringFilterProperty,
|
|
8939
9338
|
zSuspendBatchOperationData,
|
|
8940
9339
|
zSuspendBatchOperationResponse,
|
|
9340
|
+
zSuspendProcessInstanceData,
|
|
9341
|
+
zSuspendProcessInstanceRequest,
|
|
9342
|
+
zSuspendProcessInstanceResponse,
|
|
9343
|
+
zSuspendProcessInstancesBatchOperationData,
|
|
9344
|
+
zSuspendProcessInstancesBatchOperationResponse,
|
|
8941
9345
|
zSystemConfigurationResponse,
|
|
8942
9346
|
zTag,
|
|
8943
9347
|
zTagSet,
|
|
@@ -9077,4 +9481,4 @@ export {
|
|
|
9077
9481
|
zWaitStateTypeFilterProperty,
|
|
9078
9482
|
zWebappComponent
|
|
9079
9483
|
};
|
|
9080
|
-
//# sourceMappingURL=zod.gen-
|
|
9484
|
+
//# sourceMappingURL=zod.gen-EOOTXFM5.js.map
|