cyberdesk 2.2.37 → 2.2.39
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/dist/client/client/client.gen.d.ts +2 -0
- package/dist/client/client/client.gen.js +217 -0
- package/dist/client/client/index.d.ts +8 -0
- package/dist/client/client/index.js +17 -0
- package/dist/client/client/types.gen.d.ts +117 -0
- package/dist/client/client/types.gen.js +3 -0
- package/dist/client/client/utils.gen.d.ts +33 -0
- package/dist/client/client/utils.gen.js +247 -0
- package/dist/client/client.gen.d.ts +4 -4
- package/dist/client/client.gen.js +2 -4
- package/dist/client/core/auth.gen.d.ts +18 -0
- package/dist/client/core/auth.gen.js +27 -0
- package/dist/client/core/bodySerializer.gen.d.ts +25 -0
- package/dist/client/core/bodySerializer.gen.js +60 -0
- package/dist/client/core/params.gen.d.ts +43 -0
- package/dist/client/core/params.gen.js +104 -0
- package/dist/client/core/pathSerializer.gen.d.ts +33 -0
- package/dist/client/core/pathSerializer.gen.js +115 -0
- package/dist/client/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/client/core/queryKeySerializer.gen.js +98 -0
- package/dist/client/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/client/core/serverSentEvents.gen.js +160 -0
- package/dist/client/core/types.gen.d.ts +78 -0
- package/dist/client/core/types.gen.js +3 -0
- package/dist/client/core/utils.gen.d.ts +19 -0
- package/dist/client/core/utils.gen.js +93 -0
- package/dist/client/index.d.ts +2 -2
- package/dist/client/index.js +113 -17
- package/dist/client/sdk.gen.d.ts +214 -129
- package/dist/client/sdk.gen.js +212 -635
- package/dist/client/types.gen.d.ts +2329 -5
- package/dist/index.d.ts +207 -207
- package/dist/index.js +2 -2
- package/package.json +1 -1
|
@@ -1,48 +1,81 @@
|
|
|
1
|
+
export type ClientOptions = {
|
|
2
|
+
baseUrl: string;
|
|
3
|
+
};
|
|
4
|
+
export type Webhooks = RunCompleteWebhookrunCompletePostWebhookRequest;
|
|
1
5
|
/**
|
|
6
|
+
* AddTagsRequest
|
|
7
|
+
*
|
|
2
8
|
* Schema for adding tags to a workflow
|
|
3
9
|
*/
|
|
4
10
|
export type AddTagsRequest = {
|
|
5
11
|
/**
|
|
12
|
+
* Tag Ids
|
|
13
|
+
*
|
|
6
14
|
* List of tag IDs to add
|
|
7
15
|
*/
|
|
8
16
|
tag_ids: Array<string>;
|
|
9
17
|
};
|
|
18
|
+
/**
|
|
19
|
+
* AttachmentType
|
|
20
|
+
*/
|
|
10
21
|
export type AttachmentType = 'input' | 'output';
|
|
22
|
+
/**
|
|
23
|
+
* Body_upload_workflow_prompt_image_v1_workflows_prompt_image_post
|
|
24
|
+
*/
|
|
11
25
|
export type BodyUploadWorkflowPromptImageV1WorkflowsPromptImagePost = {
|
|
12
26
|
/**
|
|
27
|
+
* File
|
|
28
|
+
*
|
|
13
29
|
* The image file to upload
|
|
14
30
|
*/
|
|
15
31
|
file: Blob | File;
|
|
16
32
|
};
|
|
17
33
|
/**
|
|
34
|
+
* BulkAddTagsRequest
|
|
35
|
+
*
|
|
18
36
|
* Schema for bulk adding tags to workflows
|
|
19
37
|
*/
|
|
20
38
|
export type BulkAddTagsRequest = {
|
|
21
39
|
/**
|
|
40
|
+
* Workflow Ids
|
|
41
|
+
*
|
|
22
42
|
* List of workflow IDs to add tags to
|
|
23
43
|
*/
|
|
24
44
|
workflow_ids: Array<string>;
|
|
25
45
|
/**
|
|
46
|
+
* Tag Ids
|
|
47
|
+
*
|
|
26
48
|
* List of tag IDs to add
|
|
27
49
|
*/
|
|
28
50
|
tag_ids: Array<string>;
|
|
29
51
|
};
|
|
30
52
|
/**
|
|
53
|
+
* ChainStep
|
|
54
|
+
*
|
|
31
55
|
* One step within a chain
|
|
32
56
|
*/
|
|
33
57
|
export type ChainStep = {
|
|
58
|
+
/**
|
|
59
|
+
* Workflow Id
|
|
60
|
+
*/
|
|
34
61
|
workflow_id: string;
|
|
35
62
|
/**
|
|
63
|
+
* Session Alias
|
|
64
|
+
*
|
|
36
65
|
* Alias to persist this step's outputs within the session
|
|
37
66
|
*/
|
|
38
67
|
session_alias?: string | null;
|
|
39
68
|
/**
|
|
69
|
+
* Inputs
|
|
70
|
+
*
|
|
40
71
|
* Step-specific inputs; values can be strings, objects, arrays, or {$ref: 'alias.outputs.path'} references
|
|
41
72
|
*/
|
|
42
73
|
inputs?: {
|
|
43
74
|
[key: string]: unknown;
|
|
44
75
|
} | null;
|
|
45
76
|
/**
|
|
77
|
+
* Sensitive Inputs
|
|
78
|
+
*
|
|
46
79
|
* Step-specific sensitive inputs (supports nested objects) that override or extend shared_sensitive_inputs
|
|
47
80
|
*/
|
|
48
81
|
sensitive_inputs?: {
|
|
@@ -50,85 +83,177 @@ export type ChainStep = {
|
|
|
50
83
|
} | null;
|
|
51
84
|
};
|
|
52
85
|
/**
|
|
86
|
+
* ConnectionCreate
|
|
87
|
+
*
|
|
53
88
|
* Schema for creating a connection
|
|
54
89
|
*/
|
|
55
90
|
export type ConnectionCreate = {
|
|
91
|
+
/**
|
|
92
|
+
* Websocket Id
|
|
93
|
+
*/
|
|
56
94
|
websocket_id: string;
|
|
95
|
+
/**
|
|
96
|
+
* Ip Address
|
|
97
|
+
*/
|
|
57
98
|
ip_address?: string | null;
|
|
99
|
+
/**
|
|
100
|
+
* User Agent
|
|
101
|
+
*/
|
|
58
102
|
user_agent?: string | null;
|
|
103
|
+
/**
|
|
104
|
+
* Machine Id
|
|
105
|
+
*/
|
|
59
106
|
machine_id: string;
|
|
60
107
|
};
|
|
61
108
|
/**
|
|
109
|
+
* ConnectionResponse
|
|
110
|
+
*
|
|
62
111
|
* Connection response schema
|
|
63
112
|
*/
|
|
64
113
|
export type ConnectionResponse = {
|
|
114
|
+
/**
|
|
115
|
+
* Websocket Id
|
|
116
|
+
*/
|
|
65
117
|
websocket_id: string;
|
|
118
|
+
/**
|
|
119
|
+
* Ip Address
|
|
120
|
+
*/
|
|
66
121
|
ip_address?: string | null;
|
|
122
|
+
/**
|
|
123
|
+
* User Agent
|
|
124
|
+
*/
|
|
67
125
|
user_agent?: string | null;
|
|
126
|
+
/**
|
|
127
|
+
* Id
|
|
128
|
+
*/
|
|
68
129
|
id: string;
|
|
130
|
+
/**
|
|
131
|
+
* Machine Id
|
|
132
|
+
*/
|
|
69
133
|
machine_id: string;
|
|
134
|
+
/**
|
|
135
|
+
* Connected At
|
|
136
|
+
*/
|
|
70
137
|
connected_at: string;
|
|
138
|
+
/**
|
|
139
|
+
* Disconnected At
|
|
140
|
+
*/
|
|
71
141
|
disconnected_at: string | null;
|
|
142
|
+
/**
|
|
143
|
+
* Last Ping
|
|
144
|
+
*/
|
|
72
145
|
last_ping: string;
|
|
73
146
|
status: ConnectionStatus;
|
|
74
147
|
};
|
|
148
|
+
/**
|
|
149
|
+
* ConnectionStatus
|
|
150
|
+
*/
|
|
75
151
|
export type ConnectionStatus = 'connected' | 'disconnected' | 'error';
|
|
152
|
+
/**
|
|
153
|
+
* CopyToClipboardRequest
|
|
154
|
+
*/
|
|
76
155
|
export type CopyToClipboardRequest = {
|
|
77
156
|
/**
|
|
157
|
+
* Text
|
|
158
|
+
*
|
|
78
159
|
* Key name for the copied data
|
|
79
160
|
*/
|
|
80
161
|
text: string;
|
|
81
162
|
};
|
|
163
|
+
/**
|
|
164
|
+
* CyberdriverShutdownRequest
|
|
165
|
+
*/
|
|
82
166
|
export type CyberdriverShutdownRequest = {
|
|
83
167
|
/**
|
|
168
|
+
* Source
|
|
169
|
+
*
|
|
84
170
|
* Caller identifier for shutdown auditing
|
|
85
171
|
*/
|
|
86
172
|
source?: string;
|
|
87
173
|
/**
|
|
174
|
+
* Reason
|
|
175
|
+
*
|
|
88
176
|
* Reason for shutting down the CyberDriver process
|
|
89
177
|
*/
|
|
90
178
|
reason?: string | null;
|
|
91
179
|
};
|
|
180
|
+
/**
|
|
181
|
+
* DisplayDimensions
|
|
182
|
+
*/
|
|
92
183
|
export type DisplayDimensions = {
|
|
184
|
+
/**
|
|
185
|
+
* Width
|
|
186
|
+
*/
|
|
93
187
|
width: number;
|
|
188
|
+
/**
|
|
189
|
+
* Height
|
|
190
|
+
*/
|
|
94
191
|
height: number;
|
|
95
192
|
};
|
|
96
193
|
/**
|
|
194
|
+
* FileInput
|
|
195
|
+
*
|
|
97
196
|
* File input for run creation
|
|
98
197
|
*/
|
|
99
198
|
export type FileInput = {
|
|
199
|
+
/**
|
|
200
|
+
* Filename
|
|
201
|
+
*/
|
|
100
202
|
filename: string;
|
|
101
203
|
/**
|
|
204
|
+
* Content
|
|
205
|
+
*
|
|
102
206
|
* Base64 encoded file content
|
|
103
207
|
*/
|
|
104
208
|
content: string;
|
|
105
209
|
/**
|
|
210
|
+
* Target Path
|
|
211
|
+
*
|
|
106
212
|
* Optional path on machine, defaults to ~/CyberdeskTransfers/
|
|
107
213
|
*/
|
|
108
214
|
target_path?: string | null;
|
|
109
215
|
/**
|
|
216
|
+
* Cleanup Imports After Run
|
|
217
|
+
*
|
|
110
218
|
* Delete from machine after run completes
|
|
111
219
|
*/
|
|
112
220
|
cleanup_imports_after_run?: boolean;
|
|
113
221
|
};
|
|
222
|
+
/**
|
|
223
|
+
* FileWriteRequest
|
|
224
|
+
*/
|
|
114
225
|
export type FileWriteRequest = {
|
|
115
226
|
/**
|
|
227
|
+
* Path
|
|
228
|
+
*
|
|
116
229
|
* Target file path
|
|
117
230
|
*/
|
|
118
231
|
path: string;
|
|
119
232
|
/**
|
|
233
|
+
* Content
|
|
234
|
+
*
|
|
120
235
|
* Base64 encoded file content
|
|
121
236
|
*/
|
|
122
237
|
content: string;
|
|
123
238
|
/**
|
|
239
|
+
* Mode
|
|
240
|
+
*
|
|
124
241
|
* Write mode - 'write' or 'append'
|
|
125
242
|
*/
|
|
126
243
|
mode?: string;
|
|
127
244
|
};
|
|
245
|
+
/**
|
|
246
|
+
* HTTPValidationError
|
|
247
|
+
*/
|
|
128
248
|
export type HttpValidationError = {
|
|
249
|
+
/**
|
|
250
|
+
* Detail
|
|
251
|
+
*/
|
|
129
252
|
detail?: Array<ValidationError>;
|
|
130
253
|
};
|
|
131
254
|
/**
|
|
255
|
+
* IncludedResource
|
|
256
|
+
*
|
|
132
257
|
* A resource in the JSON:API-style included array.
|
|
133
258
|
*
|
|
134
259
|
* Each included resource has a `type` field indicating what kind of resource it is
|
|
@@ -146,677 +271,1545 @@ export type HttpValidationError = {
|
|
|
146
271
|
*/
|
|
147
272
|
export type IncludedResource = {
|
|
148
273
|
/**
|
|
274
|
+
* Type
|
|
275
|
+
*
|
|
149
276
|
* Resource type (e.g., 'workflow', 'machine', 'pool')
|
|
150
277
|
*/
|
|
151
278
|
type: string;
|
|
152
279
|
/**
|
|
280
|
+
* Id
|
|
281
|
+
*
|
|
153
282
|
* Resource UUID
|
|
154
283
|
*/
|
|
155
284
|
id: string;
|
|
156
|
-
[key: string]: unknown
|
|
285
|
+
[key: string]: unknown;
|
|
157
286
|
};
|
|
287
|
+
/**
|
|
288
|
+
* KeyboardKeyRequest
|
|
289
|
+
*/
|
|
158
290
|
export type KeyboardKeyRequest = {
|
|
291
|
+
/**
|
|
292
|
+
* Text
|
|
293
|
+
*/
|
|
159
294
|
text: string;
|
|
160
295
|
};
|
|
296
|
+
/**
|
|
297
|
+
* KeyboardTypeRequest
|
|
298
|
+
*/
|
|
161
299
|
export type KeyboardTypeRequest = {
|
|
300
|
+
/**
|
|
301
|
+
* Text
|
|
302
|
+
*/
|
|
162
303
|
text: string;
|
|
163
304
|
};
|
|
164
305
|
/**
|
|
306
|
+
* MachineCreate
|
|
307
|
+
*
|
|
165
308
|
* Schema for creating a machine
|
|
166
309
|
*/
|
|
167
310
|
export type MachineCreate = {
|
|
311
|
+
/**
|
|
312
|
+
* Name
|
|
313
|
+
*/
|
|
168
314
|
name?: string | null;
|
|
315
|
+
/**
|
|
316
|
+
* Fingerprint
|
|
317
|
+
*/
|
|
169
318
|
fingerprint: string;
|
|
319
|
+
/**
|
|
320
|
+
* Version
|
|
321
|
+
*/
|
|
170
322
|
version?: string | null;
|
|
323
|
+
/**
|
|
324
|
+
* Hostname
|
|
325
|
+
*/
|
|
171
326
|
hostname?: string | null;
|
|
327
|
+
/**
|
|
328
|
+
* Os Info
|
|
329
|
+
*/
|
|
172
330
|
os_info?: string | null;
|
|
173
331
|
/**
|
|
332
|
+
* Machine Parameters
|
|
333
|
+
*
|
|
174
334
|
* Machine-specific input values that auto-populate runs
|
|
175
335
|
*/
|
|
176
336
|
machine_parameters?: {
|
|
177
337
|
[key: string]: unknown;
|
|
178
338
|
} | null;
|
|
179
339
|
/**
|
|
340
|
+
* Machine Sensitive Parameters
|
|
341
|
+
*
|
|
180
342
|
* Machine-specific sensitive input aliases (stored in Basis Theory)
|
|
181
343
|
*/
|
|
182
344
|
machine_sensitive_parameters?: {
|
|
183
345
|
[key: string]: string;
|
|
184
346
|
} | null;
|
|
347
|
+
/**
|
|
348
|
+
* Unkey Key Id
|
|
349
|
+
*/
|
|
185
350
|
unkey_key_id: string;
|
|
186
351
|
};
|
|
352
|
+
/**
|
|
353
|
+
* MachineHealthCheckError
|
|
354
|
+
*/
|
|
187
355
|
export type MachineHealthCheckError = {
|
|
356
|
+
/**
|
|
357
|
+
* Machine Id
|
|
358
|
+
*/
|
|
188
359
|
machine_id: string;
|
|
360
|
+
/**
|
|
361
|
+
* Organization Id
|
|
362
|
+
*/
|
|
189
363
|
organization_id?: string | null;
|
|
364
|
+
/**
|
|
365
|
+
* Machine Name
|
|
366
|
+
*/
|
|
190
367
|
machine_name?: string | null;
|
|
368
|
+
/**
|
|
369
|
+
* Status Code
|
|
370
|
+
*/
|
|
191
371
|
status_code?: number | null;
|
|
372
|
+
/**
|
|
373
|
+
* Error
|
|
374
|
+
*/
|
|
192
375
|
error: string;
|
|
193
376
|
};
|
|
194
377
|
/**
|
|
378
|
+
* MachinePoolAssignment
|
|
379
|
+
*
|
|
195
380
|
* Schema for assigning machines to pools
|
|
196
381
|
*/
|
|
197
382
|
export type MachinePoolAssignment = {
|
|
198
383
|
/**
|
|
384
|
+
* Machine Ids
|
|
385
|
+
*
|
|
199
386
|
* List of machine IDs to assign to the pool
|
|
200
387
|
*/
|
|
201
388
|
machine_ids: Array<string>;
|
|
202
389
|
};
|
|
203
390
|
/**
|
|
391
|
+
* MachinePoolUpdate
|
|
392
|
+
*
|
|
204
393
|
* Schema for updating a machine's pool assignments
|
|
205
394
|
*/
|
|
206
395
|
export type MachinePoolUpdate = {
|
|
207
396
|
/**
|
|
397
|
+
* Pool Ids
|
|
398
|
+
*
|
|
208
399
|
* List of pool IDs to assign the machine to
|
|
209
400
|
*/
|
|
210
401
|
pool_ids: Array<string>;
|
|
211
402
|
};
|
|
212
403
|
/**
|
|
404
|
+
* MachineResponse
|
|
405
|
+
*
|
|
213
406
|
* Machine response schema
|
|
214
407
|
*/
|
|
215
408
|
export type MachineResponse = {
|
|
409
|
+
/**
|
|
410
|
+
* Name
|
|
411
|
+
*/
|
|
216
412
|
name?: string | null;
|
|
413
|
+
/**
|
|
414
|
+
* Fingerprint
|
|
415
|
+
*/
|
|
217
416
|
fingerprint: string;
|
|
417
|
+
/**
|
|
418
|
+
* Version
|
|
419
|
+
*/
|
|
218
420
|
version?: string | null;
|
|
421
|
+
/**
|
|
422
|
+
* Hostname
|
|
423
|
+
*/
|
|
219
424
|
hostname?: string | null;
|
|
425
|
+
/**
|
|
426
|
+
* Os Info
|
|
427
|
+
*/
|
|
220
428
|
os_info?: string | null;
|
|
221
429
|
/**
|
|
430
|
+
* Machine Parameters
|
|
431
|
+
*
|
|
222
432
|
* Machine-specific input values that auto-populate runs
|
|
223
433
|
*/
|
|
224
434
|
machine_parameters?: {
|
|
225
435
|
[key: string]: unknown;
|
|
226
436
|
} | null;
|
|
227
437
|
/**
|
|
438
|
+
* Machine Sensitive Parameters
|
|
439
|
+
*
|
|
228
440
|
* Machine-specific sensitive input aliases (stored in Basis Theory)
|
|
229
441
|
*/
|
|
230
442
|
machine_sensitive_parameters?: {
|
|
231
443
|
[key: string]: string;
|
|
232
444
|
} | null;
|
|
445
|
+
/**
|
|
446
|
+
* Id
|
|
447
|
+
*/
|
|
233
448
|
id: string;
|
|
449
|
+
/**
|
|
450
|
+
* User Id
|
|
451
|
+
*/
|
|
234
452
|
user_id?: string | null;
|
|
453
|
+
/**
|
|
454
|
+
* Organization Id
|
|
455
|
+
*/
|
|
235
456
|
organization_id?: string | null;
|
|
457
|
+
/**
|
|
458
|
+
* Unkey Key Id
|
|
459
|
+
*/
|
|
236
460
|
unkey_key_id: string;
|
|
237
461
|
status: MachineStatus;
|
|
462
|
+
/**
|
|
463
|
+
* Is Available
|
|
464
|
+
*/
|
|
238
465
|
is_available: boolean;
|
|
466
|
+
/**
|
|
467
|
+
* Reserved Session Id
|
|
468
|
+
*/
|
|
239
469
|
reserved_session_id?: string | null;
|
|
470
|
+
/**
|
|
471
|
+
* Linked Keepalive Machine Id
|
|
472
|
+
*/
|
|
240
473
|
linked_keepalive_machine_id?: string | null;
|
|
241
474
|
/**
|
|
475
|
+
* Physical Server Id
|
|
476
|
+
*
|
|
242
477
|
* Fly machine ID hosting the WebSocket connection
|
|
243
478
|
*/
|
|
244
479
|
physical_server_id?: string | null;
|
|
480
|
+
/**
|
|
481
|
+
* Created At
|
|
482
|
+
*/
|
|
245
483
|
created_at: string;
|
|
484
|
+
/**
|
|
485
|
+
* Last Seen
|
|
486
|
+
*/
|
|
246
487
|
last_seen: string;
|
|
488
|
+
/**
|
|
489
|
+
* Pools
|
|
490
|
+
*/
|
|
247
491
|
pools?: Array<PoolResponse> | null;
|
|
248
492
|
};
|
|
249
493
|
/**
|
|
494
|
+
* MachineResponseWithIncludes
|
|
495
|
+
*
|
|
250
496
|
* Machine response with optional included related resources.
|
|
251
497
|
*/
|
|
252
498
|
export type MachineResponseWithIncludes = {
|
|
499
|
+
/**
|
|
500
|
+
* Id
|
|
501
|
+
*/
|
|
253
502
|
id: string;
|
|
503
|
+
/**
|
|
504
|
+
* User Id
|
|
505
|
+
*/
|
|
254
506
|
user_id?: string | null;
|
|
507
|
+
/**
|
|
508
|
+
* Organization Id
|
|
509
|
+
*/
|
|
255
510
|
organization_id?: string | null;
|
|
511
|
+
/**
|
|
512
|
+
* Name
|
|
513
|
+
*/
|
|
256
514
|
name?: string | null;
|
|
515
|
+
/**
|
|
516
|
+
* Fingerprint
|
|
517
|
+
*/
|
|
257
518
|
fingerprint: string;
|
|
519
|
+
/**
|
|
520
|
+
* Unkey Key Id
|
|
521
|
+
*/
|
|
258
522
|
unkey_key_id: string;
|
|
523
|
+
/**
|
|
524
|
+
* Version
|
|
525
|
+
*/
|
|
259
526
|
version?: string | null;
|
|
527
|
+
/**
|
|
528
|
+
* Hostname
|
|
529
|
+
*/
|
|
260
530
|
hostname?: string | null;
|
|
531
|
+
/**
|
|
532
|
+
* Os Info
|
|
533
|
+
*/
|
|
261
534
|
os_info?: string | null;
|
|
535
|
+
/**
|
|
536
|
+
* Machine Parameters
|
|
537
|
+
*/
|
|
262
538
|
machine_parameters?: {
|
|
263
539
|
[key: string]: unknown;
|
|
264
540
|
} | null;
|
|
541
|
+
/**
|
|
542
|
+
* Machine Sensitive Parameters
|
|
543
|
+
*/
|
|
265
544
|
machine_sensitive_parameters?: {
|
|
266
545
|
[key: string]: string;
|
|
267
546
|
} | null;
|
|
268
547
|
status: MachineStatus;
|
|
548
|
+
/**
|
|
549
|
+
* Is Available
|
|
550
|
+
*/
|
|
269
551
|
is_available: boolean;
|
|
552
|
+
/**
|
|
553
|
+
* Reserved Session Id
|
|
554
|
+
*/
|
|
270
555
|
reserved_session_id?: string | null;
|
|
556
|
+
/**
|
|
557
|
+
* Linked Keepalive Machine Id
|
|
558
|
+
*/
|
|
271
559
|
linked_keepalive_machine_id?: string | null;
|
|
560
|
+
/**
|
|
561
|
+
* Physical Server Id
|
|
562
|
+
*/
|
|
272
563
|
physical_server_id?: string | null;
|
|
564
|
+
/**
|
|
565
|
+
* Created At
|
|
566
|
+
*/
|
|
273
567
|
created_at: string;
|
|
568
|
+
/**
|
|
569
|
+
* Last Seen
|
|
570
|
+
*/
|
|
274
571
|
last_seen: string;
|
|
572
|
+
/**
|
|
573
|
+
* Pools
|
|
574
|
+
*/
|
|
275
575
|
pools?: Array<PoolResponse> | null;
|
|
276
576
|
/**
|
|
577
|
+
* Included
|
|
578
|
+
*
|
|
277
579
|
* Related resources requested via the `include` query parameter
|
|
278
580
|
*/
|
|
279
581
|
included?: Array<IncludedResource> | null;
|
|
280
582
|
};
|
|
583
|
+
/**
|
|
584
|
+
* MachineStatus
|
|
585
|
+
*/
|
|
281
586
|
export type MachineStatus = 'connected' | 'disconnected' | 'error';
|
|
282
587
|
/**
|
|
588
|
+
* MachineUpdate
|
|
589
|
+
*
|
|
283
590
|
* Schema for updating a machine
|
|
284
591
|
*/
|
|
285
592
|
export type MachineUpdate = {
|
|
593
|
+
/**
|
|
594
|
+
* Name
|
|
595
|
+
*/
|
|
286
596
|
name?: string | null;
|
|
597
|
+
/**
|
|
598
|
+
* Version
|
|
599
|
+
*/
|
|
287
600
|
version?: string | null;
|
|
601
|
+
/**
|
|
602
|
+
* Hostname
|
|
603
|
+
*/
|
|
288
604
|
hostname?: string | null;
|
|
605
|
+
/**
|
|
606
|
+
* Os Info
|
|
607
|
+
*/
|
|
289
608
|
os_info?: string | null;
|
|
290
609
|
status?: MachineStatus | null;
|
|
610
|
+
/**
|
|
611
|
+
* Is Available
|
|
612
|
+
*/
|
|
291
613
|
is_available?: boolean | null;
|
|
614
|
+
/**
|
|
615
|
+
* Last Seen
|
|
616
|
+
*/
|
|
292
617
|
last_seen?: string | null;
|
|
293
618
|
/**
|
|
619
|
+
* Reserved Session Id
|
|
620
|
+
*
|
|
294
621
|
* Set to null to clear reservation; server will cancel any scheduling/running run on this machine, clear reservation, mark machine available, and trigger matching
|
|
295
622
|
*/
|
|
296
623
|
reserved_session_id?: string | null;
|
|
297
624
|
/**
|
|
625
|
+
* Machine Parameters
|
|
626
|
+
*
|
|
298
627
|
* Machine-specific input values. Provide empty dict {} to clear all.
|
|
299
628
|
*/
|
|
300
629
|
machine_parameters?: {
|
|
301
630
|
[key: string]: unknown;
|
|
302
631
|
} | null;
|
|
303
632
|
/**
|
|
633
|
+
* Machine Sensitive Parameters
|
|
634
|
+
*
|
|
304
635
|
* Machine-specific sensitive input values (will be stored in Basis Theory). Provide empty dict {} to clear all.
|
|
305
636
|
*/
|
|
306
637
|
machine_sensitive_parameters?: {
|
|
307
638
|
[key: string]: string;
|
|
308
639
|
} | null;
|
|
309
640
|
};
|
|
641
|
+
/**
|
|
642
|
+
* MachinesHealthCheckResponse
|
|
643
|
+
*/
|
|
310
644
|
export type MachinesHealthCheckResponse = {
|
|
645
|
+
/**
|
|
646
|
+
* Status
|
|
647
|
+
*/
|
|
311
648
|
status: 'ok' | 'error';
|
|
649
|
+
/**
|
|
650
|
+
* Scope
|
|
651
|
+
*/
|
|
312
652
|
scope: 'organization' | 'all_organizations';
|
|
653
|
+
/**
|
|
654
|
+
* Checked Machines
|
|
655
|
+
*/
|
|
313
656
|
checked_machines: number;
|
|
657
|
+
/**
|
|
658
|
+
* Healthy Machines
|
|
659
|
+
*/
|
|
314
660
|
healthy_machines: number;
|
|
661
|
+
/**
|
|
662
|
+
* Errored Machines
|
|
663
|
+
*/
|
|
315
664
|
errored_machines: Array<MachineHealthCheckError>;
|
|
665
|
+
/**
|
|
666
|
+
* Message
|
|
667
|
+
*/
|
|
316
668
|
message: string;
|
|
317
669
|
};
|
|
318
670
|
/**
|
|
671
|
+
* ModelConfigurationCreate
|
|
672
|
+
*
|
|
319
673
|
* Create a model configuration.
|
|
320
674
|
*
|
|
321
675
|
* `api_key` is the raw secret material; it will be stored in Basis Theory and only the alias is persisted.
|
|
322
676
|
* For providers that Cyberdesk does not provide keys for, `api_key` is required.
|
|
323
677
|
*/
|
|
324
678
|
export type ModelConfigurationCreate = {
|
|
679
|
+
/**
|
|
680
|
+
* Name
|
|
681
|
+
*/
|
|
325
682
|
name: string;
|
|
683
|
+
/**
|
|
684
|
+
* Description
|
|
685
|
+
*/
|
|
326
686
|
description?: string | null;
|
|
327
687
|
/**
|
|
688
|
+
* Provider
|
|
689
|
+
*
|
|
328
690
|
* LangChain provider name (e.g. 'anthropic', 'openai').
|
|
329
691
|
*/
|
|
330
692
|
provider: string;
|
|
331
693
|
/**
|
|
694
|
+
* Model
|
|
695
|
+
*
|
|
332
696
|
* Provider model identifier (e.g. 'claude-sonnet-4-5-20250929').
|
|
333
697
|
*/
|
|
334
698
|
model: string;
|
|
699
|
+
/**
|
|
700
|
+
* Temperature
|
|
701
|
+
*/
|
|
335
702
|
temperature?: number | null;
|
|
703
|
+
/**
|
|
704
|
+
* Max Tokens
|
|
705
|
+
*/
|
|
336
706
|
max_tokens?: number | null;
|
|
707
|
+
/**
|
|
708
|
+
* Timeout Seconds
|
|
709
|
+
*/
|
|
337
710
|
timeout_seconds?: number | null;
|
|
711
|
+
/**
|
|
712
|
+
* Max Retries
|
|
713
|
+
*/
|
|
338
714
|
max_retries?: number | null;
|
|
339
715
|
/**
|
|
716
|
+
* Additional Params
|
|
717
|
+
*
|
|
340
718
|
* Provider-specific kwargs passed through to LangChain.
|
|
341
719
|
*/
|
|
342
720
|
additional_params?: {
|
|
343
721
|
[key: string]: unknown;
|
|
344
722
|
} | null;
|
|
345
723
|
/**
|
|
724
|
+
* Agent Harness Version String
|
|
725
|
+
*
|
|
346
726
|
* Agent harness version string used by Cyberdesk workers for prompt/tool selection.
|
|
347
727
|
*/
|
|
348
728
|
agent_harness_version_string?: string | null;
|
|
349
729
|
/**
|
|
730
|
+
* Is Computer Use Model
|
|
731
|
+
*
|
|
350
732
|
* True if this model has native computer use capabilities. If True, can be used for main agent, focused actions, and fallbacks for those agents.
|
|
351
733
|
*/
|
|
352
734
|
is_computer_use_model?: boolean;
|
|
353
735
|
/**
|
|
736
|
+
* Is Archived
|
|
737
|
+
*
|
|
354
738
|
* Whether this model configuration is archived and should generally be hidden behind archived-model UI affordances.
|
|
355
739
|
*/
|
|
356
740
|
is_archived?: boolean;
|
|
357
741
|
/**
|
|
742
|
+
* Api Key
|
|
743
|
+
*
|
|
358
744
|
* Raw API key (stored in Basis Theory; never persisted directly).
|
|
359
745
|
*/
|
|
360
746
|
api_key?: string | null;
|
|
361
747
|
};
|
|
362
748
|
/**
|
|
749
|
+
* ModelConfigurationResponse
|
|
750
|
+
*
|
|
363
751
|
* API response schema for model configurations.
|
|
364
752
|
*/
|
|
365
753
|
export type ModelConfigurationResponse = {
|
|
754
|
+
/**
|
|
755
|
+
* Name
|
|
756
|
+
*/
|
|
366
757
|
name: string;
|
|
758
|
+
/**
|
|
759
|
+
* Description
|
|
760
|
+
*/
|
|
367
761
|
description?: string | null;
|
|
368
762
|
/**
|
|
763
|
+
* Provider
|
|
764
|
+
*
|
|
369
765
|
* LangChain provider name (e.g. 'anthropic', 'openai').
|
|
370
766
|
*/
|
|
371
767
|
provider: string;
|
|
372
768
|
/**
|
|
769
|
+
* Model
|
|
770
|
+
*
|
|
373
771
|
* Provider model identifier (e.g. 'claude-sonnet-4-5-20250929').
|
|
374
772
|
*/
|
|
375
773
|
model: string;
|
|
774
|
+
/**
|
|
775
|
+
* Temperature
|
|
776
|
+
*/
|
|
376
777
|
temperature?: number | null;
|
|
778
|
+
/**
|
|
779
|
+
* Max Tokens
|
|
780
|
+
*/
|
|
377
781
|
max_tokens?: number | null;
|
|
782
|
+
/**
|
|
783
|
+
* Timeout Seconds
|
|
784
|
+
*/
|
|
378
785
|
timeout_seconds?: number | null;
|
|
786
|
+
/**
|
|
787
|
+
* Max Retries
|
|
788
|
+
*/
|
|
379
789
|
max_retries?: number | null;
|
|
380
790
|
/**
|
|
791
|
+
* Additional Params
|
|
792
|
+
*
|
|
381
793
|
* Provider-specific kwargs passed through to LangChain.
|
|
382
794
|
*/
|
|
383
795
|
additional_params?: {
|
|
384
796
|
[key: string]: unknown;
|
|
385
797
|
} | null;
|
|
386
798
|
/**
|
|
799
|
+
* Agent Harness Version String
|
|
800
|
+
*
|
|
387
801
|
* Agent harness version string used by Cyberdesk workers for prompt/tool selection.
|
|
388
802
|
*/
|
|
389
803
|
agent_harness_version_string?: string | null;
|
|
390
804
|
/**
|
|
805
|
+
* Is Computer Use Model
|
|
806
|
+
*
|
|
391
807
|
* True if this model has native computer use capabilities. If True, can be used for main agent, focused actions, and fallbacks for those agents.
|
|
392
808
|
*/
|
|
393
809
|
is_computer_use_model?: boolean;
|
|
394
810
|
/**
|
|
811
|
+
* Is Archived
|
|
812
|
+
*
|
|
395
813
|
* Whether this model configuration is archived and should generally be hidden behind archived-model UI affordances.
|
|
396
814
|
*/
|
|
397
815
|
is_archived?: boolean;
|
|
816
|
+
/**
|
|
817
|
+
* Id
|
|
818
|
+
*/
|
|
398
819
|
id: string;
|
|
820
|
+
/**
|
|
821
|
+
* Organization Id
|
|
822
|
+
*/
|
|
399
823
|
organization_id?: string | null;
|
|
400
824
|
/**
|
|
825
|
+
* Api Key Alias
|
|
826
|
+
*
|
|
401
827
|
* Basis Theory token id (alias) used to resolve api_key at runtime.
|
|
402
828
|
*/
|
|
403
829
|
api_key_alias?: string | null;
|
|
830
|
+
/**
|
|
831
|
+
* Is System Default
|
|
832
|
+
*/
|
|
404
833
|
is_system_default: boolean;
|
|
834
|
+
/**
|
|
835
|
+
* Created At
|
|
836
|
+
*/
|
|
405
837
|
created_at: string;
|
|
838
|
+
/**
|
|
839
|
+
* Updated At
|
|
840
|
+
*/
|
|
406
841
|
updated_at: string;
|
|
407
842
|
};
|
|
408
843
|
/**
|
|
844
|
+
* ModelConfigurationUpdate
|
|
845
|
+
*
|
|
409
846
|
* Update a model configuration (organization-owned only).
|
|
410
847
|
*/
|
|
411
848
|
export type ModelConfigurationUpdate = {
|
|
849
|
+
/**
|
|
850
|
+
* Name
|
|
851
|
+
*/
|
|
412
852
|
name?: string | null;
|
|
853
|
+
/**
|
|
854
|
+
* Description
|
|
855
|
+
*/
|
|
413
856
|
description?: string | null;
|
|
857
|
+
/**
|
|
858
|
+
* Provider
|
|
859
|
+
*/
|
|
414
860
|
provider?: string | null;
|
|
861
|
+
/**
|
|
862
|
+
* Model
|
|
863
|
+
*/
|
|
415
864
|
model?: string | null;
|
|
416
865
|
/**
|
|
866
|
+
* Api Key
|
|
867
|
+
*
|
|
417
868
|
* Raw API key; if provided, replaces the stored alias.
|
|
418
869
|
*/
|
|
419
870
|
api_key?: string | null;
|
|
420
871
|
/**
|
|
872
|
+
* Clear Api Key
|
|
873
|
+
*
|
|
421
874
|
* If true, clears any stored api_key_alias (reverts to Cyberdesk-provided key if supported).
|
|
422
875
|
*/
|
|
423
876
|
clear_api_key?: boolean | null;
|
|
877
|
+
/**
|
|
878
|
+
* Temperature
|
|
879
|
+
*/
|
|
424
880
|
temperature?: number | null;
|
|
881
|
+
/**
|
|
882
|
+
* Max Tokens
|
|
883
|
+
*/
|
|
425
884
|
max_tokens?: number | null;
|
|
885
|
+
/**
|
|
886
|
+
* Timeout Seconds
|
|
887
|
+
*/
|
|
426
888
|
timeout_seconds?: number | null;
|
|
889
|
+
/**
|
|
890
|
+
* Max Retries
|
|
891
|
+
*/
|
|
427
892
|
max_retries?: number | null;
|
|
893
|
+
/**
|
|
894
|
+
* Additional Params
|
|
895
|
+
*/
|
|
428
896
|
additional_params?: {
|
|
429
897
|
[key: string]: unknown;
|
|
430
898
|
} | null;
|
|
899
|
+
/**
|
|
900
|
+
* Agent Harness Version String
|
|
901
|
+
*/
|
|
431
902
|
agent_harness_version_string?: string | null;
|
|
903
|
+
/**
|
|
904
|
+
* Is Computer Use Model
|
|
905
|
+
*/
|
|
432
906
|
is_computer_use_model?: boolean | null;
|
|
907
|
+
/**
|
|
908
|
+
* Is Archived
|
|
909
|
+
*/
|
|
433
910
|
is_archived?: boolean | null;
|
|
434
911
|
};
|
|
912
|
+
/**
|
|
913
|
+
* MouseClickRequest
|
|
914
|
+
*/
|
|
435
915
|
export type MouseClickRequest = {
|
|
436
|
-
|
|
916
|
+
/**
|
|
917
|
+
* X
|
|
918
|
+
*/
|
|
919
|
+
x?: number | null;
|
|
920
|
+
/**
|
|
921
|
+
* Y
|
|
922
|
+
*/
|
|
437
923
|
y?: number | null;
|
|
924
|
+
/**
|
|
925
|
+
* Button
|
|
926
|
+
*/
|
|
438
927
|
button?: string;
|
|
439
928
|
/**
|
|
929
|
+
* Down
|
|
930
|
+
*
|
|
440
931
|
* None = full click, True = mouse down, False = mouse up
|
|
441
932
|
*/
|
|
442
933
|
down?: boolean | null;
|
|
443
934
|
/**
|
|
935
|
+
* Clicks
|
|
936
|
+
*
|
|
444
937
|
* Number of clicks (1=single, 2=double, 3=triple)
|
|
445
938
|
*/
|
|
446
939
|
clicks?: number;
|
|
447
940
|
};
|
|
941
|
+
/**
|
|
942
|
+
* MouseDragRequest
|
|
943
|
+
*/
|
|
448
944
|
export type MouseDragRequest = {
|
|
945
|
+
/**
|
|
946
|
+
* To X
|
|
947
|
+
*/
|
|
449
948
|
to_x: number;
|
|
949
|
+
/**
|
|
950
|
+
* To Y
|
|
951
|
+
*/
|
|
450
952
|
to_y: number;
|
|
953
|
+
/**
|
|
954
|
+
* Start X
|
|
955
|
+
*/
|
|
451
956
|
start_x: number;
|
|
957
|
+
/**
|
|
958
|
+
* Start Y
|
|
959
|
+
*/
|
|
452
960
|
start_y: number;
|
|
961
|
+
/**
|
|
962
|
+
* Duration
|
|
963
|
+
*/
|
|
453
964
|
duration?: number | null;
|
|
454
965
|
/**
|
|
966
|
+
* Button
|
|
967
|
+
*
|
|
455
968
|
* 'left' | 'right' | 'middle'
|
|
456
969
|
*/
|
|
457
970
|
button?: string | null;
|
|
458
971
|
};
|
|
972
|
+
/**
|
|
973
|
+
* MouseMoveRequest
|
|
974
|
+
*/
|
|
459
975
|
export type MouseMoveRequest = {
|
|
976
|
+
/**
|
|
977
|
+
* X
|
|
978
|
+
*/
|
|
460
979
|
x: number;
|
|
980
|
+
/**
|
|
981
|
+
* Y
|
|
982
|
+
*/
|
|
461
983
|
y: number;
|
|
462
984
|
};
|
|
985
|
+
/**
|
|
986
|
+
* MousePosition
|
|
987
|
+
*/
|
|
463
988
|
export type MousePosition = {
|
|
989
|
+
/**
|
|
990
|
+
* X
|
|
991
|
+
*/
|
|
464
992
|
x: number;
|
|
993
|
+
/**
|
|
994
|
+
* Y
|
|
995
|
+
*/
|
|
465
996
|
y: number;
|
|
466
997
|
};
|
|
998
|
+
/**
|
|
999
|
+
* MouseScrollRequest
|
|
1000
|
+
*/
|
|
467
1001
|
export type MouseScrollRequest = {
|
|
468
1002
|
/**
|
|
1003
|
+
* Direction
|
|
1004
|
+
*
|
|
469
1005
|
* Scroll direction: 'up', 'down', 'left', or 'right'
|
|
470
1006
|
*/
|
|
471
1007
|
direction: string;
|
|
472
1008
|
/**
|
|
1009
|
+
* Amount
|
|
1010
|
+
*
|
|
473
1011
|
* Number of scroll steps (clicks); non-negative integer
|
|
474
1012
|
*/
|
|
475
1013
|
amount: number;
|
|
1014
|
+
/**
|
|
1015
|
+
* X
|
|
1016
|
+
*/
|
|
476
1017
|
x?: number | null;
|
|
1018
|
+
/**
|
|
1019
|
+
* Y
|
|
1020
|
+
*/
|
|
477
1021
|
y?: number | null;
|
|
478
1022
|
};
|
|
479
1023
|
/**
|
|
1024
|
+
* PaginatedResponse
|
|
1025
|
+
*
|
|
480
1026
|
* Paginated response wrapper
|
|
481
1027
|
*/
|
|
482
1028
|
export type PaginatedResponse = {
|
|
1029
|
+
/**
|
|
1030
|
+
* Items
|
|
1031
|
+
*/
|
|
483
1032
|
items: Array<unknown>;
|
|
1033
|
+
/**
|
|
1034
|
+
* Total
|
|
1035
|
+
*/
|
|
484
1036
|
total: number;
|
|
1037
|
+
/**
|
|
1038
|
+
* Skip
|
|
1039
|
+
*/
|
|
485
1040
|
skip: number;
|
|
1041
|
+
/**
|
|
1042
|
+
* Limit
|
|
1043
|
+
*/
|
|
486
1044
|
limit: number;
|
|
487
1045
|
};
|
|
1046
|
+
/**
|
|
1047
|
+
* PaginatedResponseWithIncludes[MachineResponse]
|
|
1048
|
+
*/
|
|
488
1049
|
export type PaginatedResponseWithIncludesMachineResponse = {
|
|
1050
|
+
/**
|
|
1051
|
+
* Items
|
|
1052
|
+
*/
|
|
489
1053
|
items: Array<MachineResponse>;
|
|
1054
|
+
/**
|
|
1055
|
+
* Total
|
|
1056
|
+
*/
|
|
490
1057
|
total: number;
|
|
1058
|
+
/**
|
|
1059
|
+
* Skip
|
|
1060
|
+
*/
|
|
491
1061
|
skip: number;
|
|
1062
|
+
/**
|
|
1063
|
+
* Limit
|
|
1064
|
+
*/
|
|
492
1065
|
limit: number;
|
|
493
1066
|
/**
|
|
1067
|
+
* Included
|
|
1068
|
+
*
|
|
494
1069
|
* Related resources requested via the `include` query parameter
|
|
495
1070
|
*/
|
|
496
1071
|
included?: Array<IncludedResource> | null;
|
|
497
1072
|
};
|
|
1073
|
+
/**
|
|
1074
|
+
* PaginatedResponseWithIncludes[PoolResponse]
|
|
1075
|
+
*/
|
|
498
1076
|
export type PaginatedResponseWithIncludesPoolResponse = {
|
|
1077
|
+
/**
|
|
1078
|
+
* Items
|
|
1079
|
+
*/
|
|
499
1080
|
items: Array<PoolResponse>;
|
|
1081
|
+
/**
|
|
1082
|
+
* Total
|
|
1083
|
+
*/
|
|
500
1084
|
total: number;
|
|
1085
|
+
/**
|
|
1086
|
+
* Skip
|
|
1087
|
+
*/
|
|
501
1088
|
skip: number;
|
|
1089
|
+
/**
|
|
1090
|
+
* Limit
|
|
1091
|
+
*/
|
|
502
1092
|
limit: number;
|
|
503
1093
|
/**
|
|
1094
|
+
* Included
|
|
1095
|
+
*
|
|
504
1096
|
* Related resources requested via the `include` query parameter
|
|
505
1097
|
*/
|
|
506
1098
|
included?: Array<IncludedResource> | null;
|
|
507
1099
|
};
|
|
1100
|
+
/**
|
|
1101
|
+
* PaginatedResponseWithIncludes[RunResponse]
|
|
1102
|
+
*/
|
|
508
1103
|
export type PaginatedResponseWithIncludesRunResponse = {
|
|
1104
|
+
/**
|
|
1105
|
+
* Items
|
|
1106
|
+
*/
|
|
509
1107
|
items: Array<RunResponseOutput>;
|
|
1108
|
+
/**
|
|
1109
|
+
* Total
|
|
1110
|
+
*/
|
|
510
1111
|
total: number;
|
|
1112
|
+
/**
|
|
1113
|
+
* Skip
|
|
1114
|
+
*/
|
|
511
1115
|
skip: number;
|
|
1116
|
+
/**
|
|
1117
|
+
* Limit
|
|
1118
|
+
*/
|
|
512
1119
|
limit: number;
|
|
513
1120
|
/**
|
|
1121
|
+
* Included
|
|
1122
|
+
*
|
|
514
1123
|
* Related resources requested via the `include` query parameter
|
|
515
1124
|
*/
|
|
516
1125
|
included?: Array<IncludedResource> | null;
|
|
517
1126
|
};
|
|
1127
|
+
/**
|
|
1128
|
+
* PaginatedResponseWithIncludes[TrajectoryResponse]
|
|
1129
|
+
*/
|
|
518
1130
|
export type PaginatedResponseWithIncludesTrajectoryResponse = {
|
|
1131
|
+
/**
|
|
1132
|
+
* Items
|
|
1133
|
+
*/
|
|
519
1134
|
items: Array<TrajectoryResponse>;
|
|
1135
|
+
/**
|
|
1136
|
+
* Total
|
|
1137
|
+
*/
|
|
520
1138
|
total: number;
|
|
1139
|
+
/**
|
|
1140
|
+
* Skip
|
|
1141
|
+
*/
|
|
521
1142
|
skip: number;
|
|
1143
|
+
/**
|
|
1144
|
+
* Limit
|
|
1145
|
+
*/
|
|
522
1146
|
limit: number;
|
|
523
1147
|
/**
|
|
1148
|
+
* Included
|
|
1149
|
+
*
|
|
524
1150
|
* Related resources requested via the `include` query parameter
|
|
525
1151
|
*/
|
|
526
1152
|
included?: Array<IncludedResource> | null;
|
|
527
1153
|
};
|
|
1154
|
+
/**
|
|
1155
|
+
* PaginatedResponseWithIncludes[WorkflowResponse]
|
|
1156
|
+
*/
|
|
528
1157
|
export type PaginatedResponseWithIncludesWorkflowResponse = {
|
|
1158
|
+
/**
|
|
1159
|
+
* Items
|
|
1160
|
+
*/
|
|
529
1161
|
items: Array<WorkflowResponse>;
|
|
1162
|
+
/**
|
|
1163
|
+
* Total
|
|
1164
|
+
*/
|
|
530
1165
|
total: number;
|
|
1166
|
+
/**
|
|
1167
|
+
* Skip
|
|
1168
|
+
*/
|
|
531
1169
|
skip: number;
|
|
1170
|
+
/**
|
|
1171
|
+
* Limit
|
|
1172
|
+
*/
|
|
532
1173
|
limit: number;
|
|
533
1174
|
/**
|
|
1175
|
+
* Included
|
|
1176
|
+
*
|
|
534
1177
|
* Related resources requested via the `include` query parameter
|
|
535
1178
|
*/
|
|
536
1179
|
included?: Array<IncludedResource> | null;
|
|
537
1180
|
};
|
|
1181
|
+
/**
|
|
1182
|
+
* PaginatedResponse[ConnectionResponse]
|
|
1183
|
+
*/
|
|
538
1184
|
export type PaginatedResponseConnectionResponse = {
|
|
1185
|
+
/**
|
|
1186
|
+
* Items
|
|
1187
|
+
*/
|
|
539
1188
|
items: Array<ConnectionResponse>;
|
|
1189
|
+
/**
|
|
1190
|
+
* Total
|
|
1191
|
+
*/
|
|
540
1192
|
total: number;
|
|
1193
|
+
/**
|
|
1194
|
+
* Skip
|
|
1195
|
+
*/
|
|
541
1196
|
skip: number;
|
|
1197
|
+
/**
|
|
1198
|
+
* Limit
|
|
1199
|
+
*/
|
|
542
1200
|
limit: number;
|
|
543
1201
|
};
|
|
1202
|
+
/**
|
|
1203
|
+
* PaginatedResponse[RunAttachmentResponse]
|
|
1204
|
+
*/
|
|
544
1205
|
export type PaginatedResponseRunAttachmentResponse = {
|
|
1206
|
+
/**
|
|
1207
|
+
* Items
|
|
1208
|
+
*/
|
|
545
1209
|
items: Array<RunAttachmentResponse>;
|
|
1210
|
+
/**
|
|
1211
|
+
* Total
|
|
1212
|
+
*/
|
|
546
1213
|
total: number;
|
|
1214
|
+
/**
|
|
1215
|
+
* Skip
|
|
1216
|
+
*/
|
|
547
1217
|
skip: number;
|
|
1218
|
+
/**
|
|
1219
|
+
* Limit
|
|
1220
|
+
*/
|
|
548
1221
|
limit: number;
|
|
549
1222
|
};
|
|
550
1223
|
/**
|
|
1224
|
+
* PoolCreate
|
|
1225
|
+
*
|
|
551
1226
|
* Schema for creating a pool
|
|
552
1227
|
*/
|
|
553
1228
|
export type PoolCreate = {
|
|
1229
|
+
/**
|
|
1230
|
+
* Name
|
|
1231
|
+
*/
|
|
554
1232
|
name: string;
|
|
1233
|
+
/**
|
|
1234
|
+
* Description
|
|
1235
|
+
*/
|
|
555
1236
|
description?: string | null;
|
|
556
1237
|
};
|
|
557
1238
|
/**
|
|
1239
|
+
* PoolResponse
|
|
1240
|
+
*
|
|
558
1241
|
* Pool response schema
|
|
559
1242
|
*/
|
|
560
1243
|
export type PoolResponse = {
|
|
1244
|
+
/**
|
|
1245
|
+
* Name
|
|
1246
|
+
*/
|
|
561
1247
|
name: string;
|
|
1248
|
+
/**
|
|
1249
|
+
* Description
|
|
1250
|
+
*/
|
|
562
1251
|
description?: string | null;
|
|
1252
|
+
/**
|
|
1253
|
+
* Id
|
|
1254
|
+
*/
|
|
563
1255
|
id: string;
|
|
1256
|
+
/**
|
|
1257
|
+
* Organization Id
|
|
1258
|
+
*/
|
|
564
1259
|
organization_id: string;
|
|
1260
|
+
/**
|
|
1261
|
+
* Created At
|
|
1262
|
+
*/
|
|
565
1263
|
created_at: string;
|
|
1264
|
+
/**
|
|
1265
|
+
* Updated At
|
|
1266
|
+
*/
|
|
566
1267
|
updated_at: string;
|
|
567
1268
|
/**
|
|
1269
|
+
* Machine Count
|
|
1270
|
+
*
|
|
568
1271
|
* Number of machines in this pool
|
|
569
1272
|
*/
|
|
570
1273
|
machine_count?: number | null;
|
|
571
1274
|
};
|
|
572
1275
|
/**
|
|
1276
|
+
* PoolResponseWithIncludes
|
|
1277
|
+
*
|
|
573
1278
|
* Pool response with optional included related resources.
|
|
574
1279
|
*/
|
|
575
1280
|
export type PoolResponseWithIncludes = {
|
|
1281
|
+
/**
|
|
1282
|
+
* Id
|
|
1283
|
+
*/
|
|
576
1284
|
id: string;
|
|
1285
|
+
/**
|
|
1286
|
+
* Organization Id
|
|
1287
|
+
*/
|
|
577
1288
|
organization_id: string;
|
|
1289
|
+
/**
|
|
1290
|
+
* Name
|
|
1291
|
+
*/
|
|
578
1292
|
name: string;
|
|
1293
|
+
/**
|
|
1294
|
+
* Description
|
|
1295
|
+
*/
|
|
579
1296
|
description?: string | null;
|
|
1297
|
+
/**
|
|
1298
|
+
* Created At
|
|
1299
|
+
*/
|
|
580
1300
|
created_at: string;
|
|
1301
|
+
/**
|
|
1302
|
+
* Updated At
|
|
1303
|
+
*/
|
|
581
1304
|
updated_at: string;
|
|
582
1305
|
/**
|
|
1306
|
+
* Machine Count
|
|
1307
|
+
*
|
|
583
1308
|
* Number of machines in this pool
|
|
584
1309
|
*/
|
|
585
1310
|
machine_count?: number | null;
|
|
586
1311
|
/**
|
|
1312
|
+
* Machines
|
|
1313
|
+
*
|
|
587
1314
|
* [Deprecated] Machines in this pool. Use `included` array instead.
|
|
588
1315
|
*/
|
|
589
1316
|
machines?: Array<MachineResponse> | null;
|
|
590
1317
|
/**
|
|
1318
|
+
* Included
|
|
1319
|
+
*
|
|
591
1320
|
* Related resources requested via the `include` query parameter
|
|
592
1321
|
*/
|
|
593
1322
|
included?: Array<IncludedResource> | null;
|
|
594
1323
|
};
|
|
595
1324
|
/**
|
|
1325
|
+
* PoolUpdate
|
|
1326
|
+
*
|
|
596
1327
|
* Schema for updating a pool
|
|
597
1328
|
*/
|
|
598
1329
|
export type PoolUpdate = {
|
|
1330
|
+
/**
|
|
1331
|
+
* Name
|
|
1332
|
+
*/
|
|
599
1333
|
name?: string | null;
|
|
1334
|
+
/**
|
|
1335
|
+
* Description
|
|
1336
|
+
*/
|
|
600
1337
|
description?: string | null;
|
|
601
1338
|
};
|
|
602
1339
|
/**
|
|
1340
|
+
* PoolWithMachines
|
|
1341
|
+
*
|
|
603
1342
|
* Pool response with machines included
|
|
604
1343
|
*/
|
|
605
1344
|
export type PoolWithMachines = {
|
|
1345
|
+
/**
|
|
1346
|
+
* Name
|
|
1347
|
+
*/
|
|
606
1348
|
name: string;
|
|
1349
|
+
/**
|
|
1350
|
+
* Description
|
|
1351
|
+
*/
|
|
607
1352
|
description?: string | null;
|
|
1353
|
+
/**
|
|
1354
|
+
* Id
|
|
1355
|
+
*/
|
|
608
1356
|
id: string;
|
|
1357
|
+
/**
|
|
1358
|
+
* Organization Id
|
|
1359
|
+
*/
|
|
609
1360
|
organization_id: string;
|
|
1361
|
+
/**
|
|
1362
|
+
* Created At
|
|
1363
|
+
*/
|
|
610
1364
|
created_at: string;
|
|
1365
|
+
/**
|
|
1366
|
+
* Updated At
|
|
1367
|
+
*/
|
|
611
1368
|
updated_at: string;
|
|
612
1369
|
/**
|
|
1370
|
+
* Machine Count
|
|
1371
|
+
*
|
|
613
1372
|
* Number of machines in this pool
|
|
614
1373
|
*/
|
|
615
1374
|
machine_count?: number | null;
|
|
1375
|
+
/**
|
|
1376
|
+
* Machines
|
|
1377
|
+
*/
|
|
616
1378
|
machines?: Array<MachineResponse>;
|
|
617
1379
|
};
|
|
1380
|
+
/**
|
|
1381
|
+
* PostRunCheckFileTargetMode
|
|
1382
|
+
*/
|
|
618
1383
|
export type PostRunCheckFileTargetMode = 'exact' | 'regex' | 'loop_items';
|
|
1384
|
+
/**
|
|
1385
|
+
* PostRunCheckStatus
|
|
1386
|
+
*/
|
|
619
1387
|
export type PostRunCheckStatus = 'pending' | 'running' | 'success' | 'failed' | 'infra_error' | 'cancelled';
|
|
1388
|
+
/**
|
|
1389
|
+
* PostRunCheckType
|
|
1390
|
+
*/
|
|
620
1391
|
export type PostRunCheckType = 'run_attachment_exists' | 'run_attachment_image_check' | 'output_data_passes_schema_validation' | 'output_data_agentic_check';
|
|
1392
|
+
/**
|
|
1393
|
+
* PowerShellExecRequest
|
|
1394
|
+
*/
|
|
621
1395
|
export type PowerShellExecRequest = {
|
|
622
1396
|
/**
|
|
1397
|
+
* Command
|
|
1398
|
+
*
|
|
623
1399
|
* PowerShell command to execute
|
|
624
1400
|
*/
|
|
625
1401
|
command: string;
|
|
626
1402
|
/**
|
|
1403
|
+
* Same Session
|
|
1404
|
+
*
|
|
627
1405
|
* Use persistent session
|
|
628
1406
|
*/
|
|
629
1407
|
same_session?: boolean;
|
|
630
1408
|
/**
|
|
1409
|
+
* Working Directory
|
|
1410
|
+
*
|
|
631
1411
|
* Working directory for new session
|
|
632
1412
|
*/
|
|
633
1413
|
working_directory?: string | null;
|
|
634
1414
|
/**
|
|
1415
|
+
* Session Id
|
|
1416
|
+
*
|
|
635
1417
|
* Session ID to use
|
|
636
1418
|
*/
|
|
637
1419
|
session_id?: string | null;
|
|
638
1420
|
/**
|
|
1421
|
+
* Timeout
|
|
1422
|
+
*
|
|
639
1423
|
* Maximum time in seconds to wait for command completion before continuing. The command will continue running in the background after timeout (default: 30.0)
|
|
640
1424
|
*/
|
|
641
1425
|
timeout?: number | null;
|
|
642
1426
|
};
|
|
1427
|
+
/**
|
|
1428
|
+
* PowerShellSessionRequest
|
|
1429
|
+
*/
|
|
643
1430
|
export type PowerShellSessionRequest = {
|
|
644
1431
|
/**
|
|
1432
|
+
* Action
|
|
1433
|
+
*
|
|
645
1434
|
* Action to perform - 'create' or 'destroy'
|
|
646
1435
|
*/
|
|
647
1436
|
action: string;
|
|
648
1437
|
/**
|
|
1438
|
+
* Session Id
|
|
1439
|
+
*
|
|
649
1440
|
* Session ID for destroy action
|
|
650
1441
|
*/
|
|
651
1442
|
session_id?: string | null;
|
|
652
1443
|
};
|
|
653
1444
|
/**
|
|
1445
|
+
* ReorderRequest
|
|
1446
|
+
*
|
|
654
1447
|
* Schema for reordering tags or groups
|
|
655
1448
|
*/
|
|
656
1449
|
export type ReorderRequest = {
|
|
657
1450
|
/**
|
|
1451
|
+
* Ids
|
|
1452
|
+
*
|
|
658
1453
|
* List of IDs in desired order
|
|
659
1454
|
*/
|
|
660
1455
|
ids: Array<string>;
|
|
661
1456
|
};
|
|
662
1457
|
/**
|
|
1458
|
+
* RequestLogCreate
|
|
1459
|
+
*
|
|
663
1460
|
* Schema for creating a request log
|
|
664
1461
|
*/
|
|
665
1462
|
export type RequestLogCreate = {
|
|
1463
|
+
/**
|
|
1464
|
+
* Request Id
|
|
1465
|
+
*/
|
|
666
1466
|
request_id: string;
|
|
1467
|
+
/**
|
|
1468
|
+
* Method
|
|
1469
|
+
*/
|
|
667
1470
|
method: string;
|
|
1471
|
+
/**
|
|
1472
|
+
* Path
|
|
1473
|
+
*/
|
|
668
1474
|
path: string;
|
|
1475
|
+
/**
|
|
1476
|
+
* Status Code
|
|
1477
|
+
*/
|
|
669
1478
|
status_code?: number | null;
|
|
1479
|
+
/**
|
|
1480
|
+
* Request Size Bytes
|
|
1481
|
+
*/
|
|
670
1482
|
request_size_bytes?: number | null;
|
|
1483
|
+
/**
|
|
1484
|
+
* Response Size Bytes
|
|
1485
|
+
*/
|
|
671
1486
|
response_size_bytes?: number | null;
|
|
1487
|
+
/**
|
|
1488
|
+
* Duration Ms
|
|
1489
|
+
*/
|
|
672
1490
|
duration_ms?: number | null;
|
|
1491
|
+
/**
|
|
1492
|
+
* Error Message
|
|
1493
|
+
*/
|
|
673
1494
|
error_message?: string | null;
|
|
1495
|
+
/**
|
|
1496
|
+
* Machine Id
|
|
1497
|
+
*/
|
|
674
1498
|
machine_id: string;
|
|
675
1499
|
};
|
|
676
1500
|
/**
|
|
1501
|
+
* RequestLogResponse
|
|
1502
|
+
*
|
|
677
1503
|
* Request log response schema
|
|
678
1504
|
*/
|
|
679
1505
|
export type RequestLogResponse = {
|
|
1506
|
+
/**
|
|
1507
|
+
* Request Id
|
|
1508
|
+
*/
|
|
680
1509
|
request_id: string;
|
|
1510
|
+
/**
|
|
1511
|
+
* Method
|
|
1512
|
+
*/
|
|
681
1513
|
method: string;
|
|
1514
|
+
/**
|
|
1515
|
+
* Path
|
|
1516
|
+
*/
|
|
682
1517
|
path: string;
|
|
1518
|
+
/**
|
|
1519
|
+
* Status Code
|
|
1520
|
+
*/
|
|
683
1521
|
status_code?: number | null;
|
|
1522
|
+
/**
|
|
1523
|
+
* Request Size Bytes
|
|
1524
|
+
*/
|
|
684
1525
|
request_size_bytes?: number | null;
|
|
1526
|
+
/**
|
|
1527
|
+
* Response Size Bytes
|
|
1528
|
+
*/
|
|
685
1529
|
response_size_bytes?: number | null;
|
|
1530
|
+
/**
|
|
1531
|
+
* Duration Ms
|
|
1532
|
+
*/
|
|
686
1533
|
duration_ms?: number | null;
|
|
1534
|
+
/**
|
|
1535
|
+
* Error Message
|
|
1536
|
+
*/
|
|
687
1537
|
error_message?: string | null;
|
|
1538
|
+
/**
|
|
1539
|
+
* Id
|
|
1540
|
+
*/
|
|
688
1541
|
id: string;
|
|
1542
|
+
/**
|
|
1543
|
+
* Machine Id
|
|
1544
|
+
*/
|
|
689
1545
|
machine_id: string;
|
|
1546
|
+
/**
|
|
1547
|
+
* Organization Id
|
|
1548
|
+
*/
|
|
690
1549
|
organization_id?: string | null;
|
|
1550
|
+
/**
|
|
1551
|
+
* Created At
|
|
1552
|
+
*/
|
|
691
1553
|
created_at: string;
|
|
1554
|
+
/**
|
|
1555
|
+
* Completed At
|
|
1556
|
+
*/
|
|
692
1557
|
completed_at: string | null;
|
|
693
1558
|
};
|
|
694
1559
|
/**
|
|
1560
|
+
* RequestLogUpdate
|
|
1561
|
+
*
|
|
695
1562
|
* Schema for updating a request log
|
|
696
1563
|
*/
|
|
697
1564
|
export type RequestLogUpdate = {
|
|
1565
|
+
/**
|
|
1566
|
+
* Status Code
|
|
1567
|
+
*/
|
|
698
1568
|
status_code?: number | null;
|
|
1569
|
+
/**
|
|
1570
|
+
* Response Size Bytes
|
|
1571
|
+
*/
|
|
699
1572
|
response_size_bytes?: number | null;
|
|
1573
|
+
/**
|
|
1574
|
+
* Completed At
|
|
1575
|
+
*/
|
|
700
1576
|
completed_at?: string | null;
|
|
1577
|
+
/**
|
|
1578
|
+
* Duration Ms
|
|
1579
|
+
*/
|
|
701
1580
|
duration_ms?: number | null;
|
|
1581
|
+
/**
|
|
1582
|
+
* Error Message
|
|
1583
|
+
*/
|
|
702
1584
|
error_message?: string | null;
|
|
703
1585
|
};
|
|
704
1586
|
/**
|
|
1587
|
+
* RunAttachmentCreate
|
|
1588
|
+
*
|
|
705
1589
|
* Schema for creating a run attachment
|
|
706
1590
|
*/
|
|
707
1591
|
export type RunAttachmentCreate = {
|
|
1592
|
+
/**
|
|
1593
|
+
* Run Id
|
|
1594
|
+
*/
|
|
708
1595
|
run_id: string;
|
|
1596
|
+
/**
|
|
1597
|
+
* Filename
|
|
1598
|
+
*/
|
|
709
1599
|
filename: string;
|
|
710
1600
|
/**
|
|
1601
|
+
* Content
|
|
1602
|
+
*
|
|
711
1603
|
* Base64 encoded file content
|
|
712
1604
|
*/
|
|
713
1605
|
content: string;
|
|
1606
|
+
/**
|
|
1607
|
+
* Content Type
|
|
1608
|
+
*/
|
|
714
1609
|
content_type: string;
|
|
715
1610
|
attachment_type: AttachmentType;
|
|
1611
|
+
/**
|
|
1612
|
+
* Target Path
|
|
1613
|
+
*/
|
|
716
1614
|
target_path?: string | null;
|
|
1615
|
+
/**
|
|
1616
|
+
* Cleanup Imports After Run
|
|
1617
|
+
*/
|
|
717
1618
|
cleanup_imports_after_run?: boolean;
|
|
1619
|
+
/**
|
|
1620
|
+
* Expires At
|
|
1621
|
+
*/
|
|
718
1622
|
expires_at?: string | null;
|
|
719
1623
|
};
|
|
720
1624
|
/**
|
|
1625
|
+
* RunAttachmentDownloadUrlResponse
|
|
1626
|
+
*
|
|
721
1627
|
* Response schema for run attachment download URL
|
|
722
1628
|
*/
|
|
723
1629
|
export type RunAttachmentDownloadUrlResponse = {
|
|
724
1630
|
/**
|
|
1631
|
+
* Url
|
|
1632
|
+
*
|
|
725
1633
|
* Signed URL for downloading the attachment
|
|
726
1634
|
*/
|
|
727
1635
|
url: string;
|
|
728
1636
|
/**
|
|
1637
|
+
* Expires In
|
|
1638
|
+
*
|
|
729
1639
|
* Seconds until the URL expires
|
|
730
1640
|
*/
|
|
731
1641
|
expires_in: number;
|
|
732
1642
|
};
|
|
733
1643
|
/**
|
|
1644
|
+
* RunAttachmentResponse
|
|
1645
|
+
*
|
|
734
1646
|
* Run attachment response schema
|
|
735
1647
|
*/
|
|
736
1648
|
export type RunAttachmentResponse = {
|
|
1649
|
+
/**
|
|
1650
|
+
* Filename
|
|
1651
|
+
*/
|
|
737
1652
|
filename: string;
|
|
1653
|
+
/**
|
|
1654
|
+
* Content Type
|
|
1655
|
+
*/
|
|
738
1656
|
content_type: string;
|
|
739
1657
|
attachment_type: AttachmentType;
|
|
1658
|
+
/**
|
|
1659
|
+
* Target Path
|
|
1660
|
+
*/
|
|
740
1661
|
target_path?: string | null;
|
|
1662
|
+
/**
|
|
1663
|
+
* Cleanup Imports After Run
|
|
1664
|
+
*/
|
|
741
1665
|
cleanup_imports_after_run?: boolean;
|
|
1666
|
+
/**
|
|
1667
|
+
* Id
|
|
1668
|
+
*/
|
|
742
1669
|
id: string;
|
|
1670
|
+
/**
|
|
1671
|
+
* User Id
|
|
1672
|
+
*/
|
|
743
1673
|
user_id?: string | null;
|
|
1674
|
+
/**
|
|
1675
|
+
* Organization Id
|
|
1676
|
+
*/
|
|
744
1677
|
organization_id?: string | null;
|
|
1678
|
+
/**
|
|
1679
|
+
* Run Id
|
|
1680
|
+
*/
|
|
745
1681
|
run_id: string;
|
|
1682
|
+
/**
|
|
1683
|
+
* Size Bytes
|
|
1684
|
+
*/
|
|
746
1685
|
size_bytes: number;
|
|
1686
|
+
/**
|
|
1687
|
+
* Storage Path
|
|
1688
|
+
*/
|
|
747
1689
|
storage_path: string;
|
|
1690
|
+
/**
|
|
1691
|
+
* Expires At
|
|
1692
|
+
*/
|
|
748
1693
|
expires_at?: string | null;
|
|
1694
|
+
/**
|
|
1695
|
+
* Created At
|
|
1696
|
+
*/
|
|
749
1697
|
created_at: string;
|
|
750
1698
|
};
|
|
751
1699
|
/**
|
|
1700
|
+
* RunAttachmentUpdate
|
|
1701
|
+
*
|
|
752
1702
|
* Schema for updating a run attachment
|
|
753
1703
|
*/
|
|
754
1704
|
export type RunAttachmentUpdate = {
|
|
1705
|
+
/**
|
|
1706
|
+
* Expires At
|
|
1707
|
+
*/
|
|
755
1708
|
expires_at?: string | null;
|
|
756
1709
|
};
|
|
757
1710
|
/**
|
|
1711
|
+
* RunBulkCreate
|
|
1712
|
+
*
|
|
758
1713
|
* Schema for bulk creating runs
|
|
759
1714
|
*/
|
|
760
1715
|
export type RunBulkCreate = {
|
|
1716
|
+
/**
|
|
1717
|
+
* Workflow Id
|
|
1718
|
+
*/
|
|
761
1719
|
workflow_id: string;
|
|
762
1720
|
/**
|
|
1721
|
+
* Machine Id
|
|
1722
|
+
*
|
|
763
1723
|
* Machine ID. If not provided, an available machine will be automatically selected.
|
|
764
1724
|
*/
|
|
765
1725
|
machine_id?: string | null;
|
|
766
1726
|
/**
|
|
1727
|
+
* Pool Ids
|
|
1728
|
+
*
|
|
767
1729
|
* Pool IDs to filter available machines. Machine must belong to all of these pools (intersection). Ignored when machine_id is provided.
|
|
768
1730
|
*/
|
|
769
1731
|
pool_ids?: Array<string> | null;
|
|
770
1732
|
/**
|
|
1733
|
+
* Input Values
|
|
1734
|
+
*
|
|
771
1735
|
* Input values for workflow variables
|
|
772
1736
|
*/
|
|
773
1737
|
input_values?: {
|
|
774
1738
|
[key: string]: unknown;
|
|
775
1739
|
} | null;
|
|
776
1740
|
/**
|
|
1741
|
+
* File Inputs
|
|
1742
|
+
*
|
|
777
1743
|
* Files to upload to the machine
|
|
778
1744
|
*/
|
|
779
1745
|
file_inputs?: Array<FileInput> | null;
|
|
780
1746
|
/**
|
|
1747
|
+
* Count
|
|
1748
|
+
*
|
|
781
1749
|
* Number of runs to create (max 1000)
|
|
782
1750
|
*/
|
|
783
1751
|
count: number;
|
|
784
1752
|
/**
|
|
1753
|
+
* Sensitive Input Values
|
|
1754
|
+
*
|
|
785
1755
|
* Sensitive input values (supports nested objects) to store in the secure vault per run. Not persisted in our database. In workflow input_schema, sensitive root keys are validated under a '$' prefixed key.
|
|
786
1756
|
*/
|
|
787
1757
|
sensitive_input_values?: {
|
|
788
1758
|
[key: string]: unknown;
|
|
789
1759
|
} | null;
|
|
790
1760
|
/**
|
|
1761
|
+
* Session Id
|
|
1762
|
+
*
|
|
791
1763
|
* Join an existing session; overrides machine_id/pool_ids for all runs
|
|
792
1764
|
*/
|
|
793
1765
|
session_id?: string | null;
|
|
794
1766
|
/**
|
|
1767
|
+
* Start Session
|
|
1768
|
+
*
|
|
795
1769
|
* Start a new session for these runs; a new UUID will be generated and set on all runs. The first run will attempt to reserve a machine.
|
|
796
1770
|
*/
|
|
797
1771
|
start_session?: boolean | null;
|
|
798
1772
|
};
|
|
799
1773
|
/**
|
|
1774
|
+
* RunBulkCreateResponse
|
|
1775
|
+
*
|
|
800
1776
|
* Response for bulk run creation
|
|
801
1777
|
*/
|
|
802
1778
|
export type RunBulkCreateResponse = {
|
|
1779
|
+
/**
|
|
1780
|
+
* Created Runs
|
|
1781
|
+
*/
|
|
803
1782
|
created_runs: Array<RunResponseOutput>;
|
|
1783
|
+
/**
|
|
1784
|
+
* Failed Count
|
|
1785
|
+
*/
|
|
804
1786
|
failed_count?: number;
|
|
1787
|
+
/**
|
|
1788
|
+
* Errors
|
|
1789
|
+
*/
|
|
805
1790
|
errors?: Array<string>;
|
|
806
1791
|
};
|
|
807
1792
|
/**
|
|
1793
|
+
* RunCompletedEvent
|
|
1794
|
+
*
|
|
808
1795
|
* Payload sent for the run_complete webhook event.
|
|
809
1796
|
*/
|
|
810
1797
|
export type RunCompletedEvent = {
|
|
811
1798
|
/**
|
|
1799
|
+
* Event Id
|
|
1800
|
+
*
|
|
812
1801
|
* Unique event identifier for idempotency
|
|
813
1802
|
*/
|
|
814
1803
|
event_id?: string;
|
|
815
1804
|
/**
|
|
1805
|
+
* Event Type
|
|
1806
|
+
*
|
|
816
1807
|
* Event type key
|
|
817
1808
|
*/
|
|
818
1809
|
event_type?: string;
|
|
819
1810
|
/**
|
|
1811
|
+
* Occurred At
|
|
1812
|
+
*
|
|
820
1813
|
* Time the event occurred (UTC)
|
|
821
1814
|
*/
|
|
822
1815
|
occurred_at?: string;
|
|
@@ -826,174 +1819,389 @@ export type RunCompletedEvent = {
|
|
|
826
1819
|
run: RunResponseInput;
|
|
827
1820
|
};
|
|
828
1821
|
/**
|
|
1822
|
+
* RunCreate
|
|
1823
|
+
*
|
|
829
1824
|
* Schema for creating a run
|
|
830
1825
|
*/
|
|
831
1826
|
export type RunCreate = {
|
|
1827
|
+
/**
|
|
1828
|
+
* Workflow Id
|
|
1829
|
+
*/
|
|
832
1830
|
workflow_id: string;
|
|
833
1831
|
/**
|
|
1832
|
+
* Machine Id
|
|
1833
|
+
*
|
|
834
1834
|
* Machine ID. If not provided, an available machine will be automatically selected.
|
|
835
1835
|
*/
|
|
836
1836
|
machine_id?: string | null;
|
|
837
1837
|
/**
|
|
1838
|
+
* Pool Ids
|
|
1839
|
+
*
|
|
838
1840
|
* Pool IDs to filter available machines. Machine must belong to all of these pools (intersection). Ignored when machine_id is provided.
|
|
839
1841
|
*/
|
|
840
1842
|
pool_ids?: Array<string> | null;
|
|
841
1843
|
/**
|
|
1844
|
+
* Input Values
|
|
1845
|
+
*
|
|
842
1846
|
* Input values for workflow variables
|
|
843
1847
|
*/
|
|
844
1848
|
input_values?: {
|
|
845
1849
|
[key: string]: unknown;
|
|
846
1850
|
} | null;
|
|
847
1851
|
/**
|
|
1852
|
+
* File Inputs
|
|
1853
|
+
*
|
|
848
1854
|
* Files to upload to the machine
|
|
849
1855
|
*/
|
|
850
1856
|
file_inputs?: Array<FileInput> | null;
|
|
851
1857
|
/**
|
|
1858
|
+
* Sensitive Input Values
|
|
1859
|
+
*
|
|
852
1860
|
* Sensitive input values (supports nested objects). These are not stored and will be written to a secure vault and referenced by alias only. In workflow input_schema, sensitive root keys are validated under a '$' prefixed key (for example input key 'api_key' is '$api_key').
|
|
853
1861
|
*/
|
|
854
1862
|
sensitive_input_values?: {
|
|
855
1863
|
[key: string]: unknown;
|
|
856
1864
|
} | null;
|
|
857
1865
|
/**
|
|
1866
|
+
* Session Id
|
|
1867
|
+
*
|
|
858
1868
|
* Join an existing session; overrides machine_id/pool_ids
|
|
859
1869
|
*/
|
|
860
1870
|
session_id?: string | null;
|
|
861
1871
|
/**
|
|
1872
|
+
* Start Session
|
|
1873
|
+
*
|
|
862
1874
|
* Start a new session on the machine used by this run. Session ID will be this run's ID.
|
|
863
1875
|
*/
|
|
864
1876
|
start_session?: boolean | null;
|
|
865
1877
|
/**
|
|
1878
|
+
* Session Alias
|
|
1879
|
+
*
|
|
866
1880
|
* Persist outputs under this alias for $ref in this session
|
|
867
1881
|
*/
|
|
868
1882
|
session_alias?: string | null;
|
|
869
1883
|
/**
|
|
1884
|
+
* Release Session After
|
|
1885
|
+
*
|
|
870
1886
|
* Release the session after this run completes successfully
|
|
871
1887
|
*/
|
|
872
1888
|
release_session_after?: boolean | null;
|
|
873
1889
|
};
|
|
874
1890
|
/**
|
|
1891
|
+
* RunField
|
|
1892
|
+
*
|
|
875
1893
|
* Selectable run fields for projection in list endpoints.
|
|
876
1894
|
*
|
|
877
1895
|
* These are optional fields beyond the essential identifiers that are always returned
|
|
878
1896
|
* (id, workflow_id, machine_id, status, created_at).
|
|
879
1897
|
*/
|
|
880
1898
|
export type RunField = 'user_id' | 'organization_id' | 'error' | 'output_data' | 'input_attachment_ids' | 'output_attachment_ids' | 'run_message_history' | 'input_values' | 'pool_ids' | 'sensitive_input_aliases' | 'usage_metadata' | 'session_id' | 'session_alias' | 'release_session_after' | 'started_at' | 'ended_at' | 'post_run_checks' | 'machine_id';
|
|
1899
|
+
/**
|
|
1900
|
+
* RunListSortMode
|
|
1901
|
+
*/
|
|
881
1902
|
export type RunListSortMode = 'activity' | 'created_at_desc';
|
|
882
1903
|
/**
|
|
1904
|
+
* RunPostRunCheckSnapshot
|
|
1905
|
+
*
|
|
883
1906
|
* Version-tolerant run-level snapshot/result for one post-run check invocation.
|
|
884
1907
|
*/
|
|
885
1908
|
export type RunPostRunCheckSnapshot = {
|
|
1909
|
+
/**
|
|
1910
|
+
* Id
|
|
1911
|
+
*/
|
|
886
1912
|
id?: string | null;
|
|
1913
|
+
/**
|
|
1914
|
+
* Post Run Check Id
|
|
1915
|
+
*/
|
|
887
1916
|
post_run_check_id?: string | null;
|
|
1917
|
+
/**
|
|
1918
|
+
* Snapshot Version
|
|
1919
|
+
*/
|
|
888
1920
|
snapshot_version?: number | null;
|
|
1921
|
+
/**
|
|
1922
|
+
* Name
|
|
1923
|
+
*/
|
|
889
1924
|
name?: string | null;
|
|
1925
|
+
/**
|
|
1926
|
+
* Description
|
|
1927
|
+
*/
|
|
890
1928
|
description?: string | null;
|
|
891
1929
|
type?: PostRunCheckType | null;
|
|
1930
|
+
/**
|
|
1931
|
+
* Order
|
|
1932
|
+
*/
|
|
892
1933
|
order?: number | null;
|
|
893
1934
|
file_target_mode?: PostRunCheckFileTargetMode | null;
|
|
1935
|
+
/**
|
|
1936
|
+
* File Names
|
|
1937
|
+
*/
|
|
894
1938
|
file_names?: Array<string> | null;
|
|
1939
|
+
/**
|
|
1940
|
+
* File Name Regex
|
|
1941
|
+
*/
|
|
895
1942
|
file_name_regex?: string | null;
|
|
1943
|
+
/**
|
|
1944
|
+
* Expected Match Count
|
|
1945
|
+
*/
|
|
896
1946
|
expected_match_count?: number | null;
|
|
1947
|
+
/**
|
|
1948
|
+
* Expected Match Count Ref
|
|
1949
|
+
*/
|
|
897
1950
|
expected_match_count_ref?: string | null;
|
|
1951
|
+
/**
|
|
1952
|
+
* Loop Input
|
|
1953
|
+
*/
|
|
898
1954
|
loop_input?: string | null;
|
|
1955
|
+
/**
|
|
1956
|
+
* Loop Item Filename Template
|
|
1957
|
+
*/
|
|
899
1958
|
loop_item_filename_template?: string | null;
|
|
1959
|
+
/**
|
|
1960
|
+
* Check Prompt
|
|
1961
|
+
*/
|
|
900
1962
|
check_prompt?: string | null;
|
|
1963
|
+
/**
|
|
1964
|
+
* Model
|
|
1965
|
+
*/
|
|
901
1966
|
model?: string | null;
|
|
902
1967
|
status: PostRunCheckStatus;
|
|
1968
|
+
/**
|
|
1969
|
+
* Started At
|
|
1970
|
+
*/
|
|
903
1971
|
started_at?: string | null;
|
|
1972
|
+
/**
|
|
1973
|
+
* Ended At
|
|
1974
|
+
*/
|
|
904
1975
|
ended_at?: string | null;
|
|
1976
|
+
/**
|
|
1977
|
+
* Error Message
|
|
1978
|
+
*/
|
|
905
1979
|
error_message?: string | null;
|
|
1980
|
+
/**
|
|
1981
|
+
* Messages
|
|
1982
|
+
*/
|
|
906
1983
|
messages?: Array<string> | null;
|
|
1984
|
+
/**
|
|
1985
|
+
* Matched Filenames
|
|
1986
|
+
*/
|
|
907
1987
|
matched_filenames?: Array<string> | null;
|
|
908
|
-
[key: string]: unknown
|
|
1988
|
+
[key: string]: unknown;
|
|
909
1989
|
};
|
|
910
1990
|
/**
|
|
1991
|
+
* RunResponse
|
|
1992
|
+
*
|
|
911
1993
|
* Run response schema
|
|
912
1994
|
*/
|
|
913
1995
|
export type RunResponseInput = {
|
|
1996
|
+
/**
|
|
1997
|
+
* Workflow Id
|
|
1998
|
+
*/
|
|
914
1999
|
workflow_id: string;
|
|
2000
|
+
/**
|
|
2001
|
+
* Machine Id
|
|
2002
|
+
*/
|
|
915
2003
|
machine_id: string | null;
|
|
2004
|
+
/**
|
|
2005
|
+
* Id
|
|
2006
|
+
*/
|
|
916
2007
|
id: string;
|
|
2008
|
+
/**
|
|
2009
|
+
* User Id
|
|
2010
|
+
*/
|
|
917
2011
|
user_id?: string | null;
|
|
2012
|
+
/**
|
|
2013
|
+
* Organization Id
|
|
2014
|
+
*/
|
|
918
2015
|
organization_id?: string | null;
|
|
919
2016
|
status: RunStatus;
|
|
2017
|
+
/**
|
|
2018
|
+
* Error
|
|
2019
|
+
*/
|
|
920
2020
|
error?: Array<string> | null;
|
|
2021
|
+
/**
|
|
2022
|
+
* Output Data
|
|
2023
|
+
*/
|
|
921
2024
|
output_data?: {
|
|
922
2025
|
[key: string]: unknown;
|
|
923
2026
|
} | null;
|
|
2027
|
+
/**
|
|
2028
|
+
* Input Attachment Ids
|
|
2029
|
+
*/
|
|
924
2030
|
input_attachment_ids?: Array<string> | null;
|
|
2031
|
+
/**
|
|
2032
|
+
* Output Attachment Ids
|
|
2033
|
+
*/
|
|
925
2034
|
output_attachment_ids?: Array<string> | null;
|
|
2035
|
+
/**
|
|
2036
|
+
* Run Message History
|
|
2037
|
+
*/
|
|
926
2038
|
run_message_history?: Array<{
|
|
927
2039
|
[key: string]: unknown;
|
|
928
2040
|
}> | null;
|
|
2041
|
+
/**
|
|
2042
|
+
* Input Values
|
|
2043
|
+
*/
|
|
929
2044
|
input_values?: {
|
|
930
2045
|
[key: string]: unknown;
|
|
931
2046
|
} | null;
|
|
2047
|
+
/**
|
|
2048
|
+
* Pool Ids
|
|
2049
|
+
*/
|
|
932
2050
|
pool_ids?: Array<string> | null;
|
|
2051
|
+
/**
|
|
2052
|
+
* Sensitive Input Aliases
|
|
2053
|
+
*/
|
|
933
2054
|
sensitive_input_aliases?: {
|
|
934
2055
|
[key: string]: string;
|
|
935
2056
|
} | null;
|
|
936
2057
|
/**
|
|
2058
|
+
* Usage Metadata
|
|
2059
|
+
*
|
|
937
2060
|
* Arbitrary usage/billing metadata captured during a run (schema is flexible)
|
|
938
2061
|
*/
|
|
939
2062
|
usage_metadata?: {
|
|
940
2063
|
[key: string]: unknown;
|
|
941
2064
|
} | null;
|
|
942
2065
|
/**
|
|
2066
|
+
* Post Run Checks
|
|
2067
|
+
*
|
|
943
2068
|
* Version-tolerant snapshot/results for the run's post-run checks.
|
|
944
2069
|
*/
|
|
945
2070
|
post_run_checks?: Array<RunPostRunCheckSnapshot> | null;
|
|
2071
|
+
/**
|
|
2072
|
+
* Session Id
|
|
2073
|
+
*/
|
|
946
2074
|
session_id?: string | null;
|
|
2075
|
+
/**
|
|
2076
|
+
* Session Alias
|
|
2077
|
+
*/
|
|
947
2078
|
session_alias?: string | null;
|
|
2079
|
+
/**
|
|
2080
|
+
* Release Session After
|
|
2081
|
+
*/
|
|
948
2082
|
release_session_after?: boolean | null;
|
|
2083
|
+
/**
|
|
2084
|
+
* Created At
|
|
2085
|
+
*/
|
|
949
2086
|
created_at: string;
|
|
2087
|
+
/**
|
|
2088
|
+
* Started At
|
|
2089
|
+
*/
|
|
950
2090
|
started_at?: string | null;
|
|
2091
|
+
/**
|
|
2092
|
+
* Ended At
|
|
2093
|
+
*/
|
|
951
2094
|
ended_at?: string | null;
|
|
952
2095
|
};
|
|
953
2096
|
/**
|
|
2097
|
+
* RunResponse
|
|
2098
|
+
*
|
|
954
2099
|
* Run response schema
|
|
955
2100
|
*/
|
|
956
2101
|
export type RunResponseOutput = {
|
|
2102
|
+
/**
|
|
2103
|
+
* Workflow Id
|
|
2104
|
+
*/
|
|
957
2105
|
workflow_id: string;
|
|
2106
|
+
/**
|
|
2107
|
+
* Machine Id
|
|
2108
|
+
*/
|
|
958
2109
|
machine_id: string | null;
|
|
2110
|
+
/**
|
|
2111
|
+
* Id
|
|
2112
|
+
*/
|
|
959
2113
|
id: string;
|
|
2114
|
+
/**
|
|
2115
|
+
* User Id
|
|
2116
|
+
*/
|
|
960
2117
|
user_id?: string | null;
|
|
2118
|
+
/**
|
|
2119
|
+
* Organization Id
|
|
2120
|
+
*/
|
|
961
2121
|
organization_id?: string | null;
|
|
962
2122
|
status: RunStatus;
|
|
2123
|
+
/**
|
|
2124
|
+
* Error
|
|
2125
|
+
*/
|
|
963
2126
|
error?: Array<string> | null;
|
|
2127
|
+
/**
|
|
2128
|
+
* Output Data
|
|
2129
|
+
*/
|
|
964
2130
|
output_data?: {
|
|
965
2131
|
[key: string]: unknown;
|
|
966
2132
|
} | null;
|
|
2133
|
+
/**
|
|
2134
|
+
* Input Attachment Ids
|
|
2135
|
+
*/
|
|
967
2136
|
input_attachment_ids?: Array<string> | null;
|
|
2137
|
+
/**
|
|
2138
|
+
* Output Attachment Ids
|
|
2139
|
+
*/
|
|
968
2140
|
output_attachment_ids?: Array<string> | null;
|
|
2141
|
+
/**
|
|
2142
|
+
* Run Message History
|
|
2143
|
+
*/
|
|
969
2144
|
run_message_history?: Array<{
|
|
970
2145
|
[key: string]: unknown;
|
|
971
2146
|
}> | null;
|
|
2147
|
+
/**
|
|
2148
|
+
* Input Values
|
|
2149
|
+
*/
|
|
972
2150
|
input_values?: {
|
|
973
2151
|
[key: string]: unknown;
|
|
974
2152
|
} | null;
|
|
2153
|
+
/**
|
|
2154
|
+
* Pool Ids
|
|
2155
|
+
*/
|
|
975
2156
|
pool_ids?: Array<string> | null;
|
|
2157
|
+
/**
|
|
2158
|
+
* Sensitive Input Aliases
|
|
2159
|
+
*/
|
|
976
2160
|
sensitive_input_aliases?: {
|
|
977
2161
|
[key: string]: string;
|
|
978
2162
|
} | null;
|
|
979
2163
|
/**
|
|
2164
|
+
* Usage Metadata
|
|
2165
|
+
*
|
|
980
2166
|
* Arbitrary usage/billing metadata captured during a run (schema is flexible)
|
|
981
2167
|
*/
|
|
982
2168
|
usage_metadata?: {
|
|
983
2169
|
[key: string]: unknown;
|
|
984
2170
|
} | null;
|
|
985
2171
|
/**
|
|
2172
|
+
* Post Run Checks
|
|
2173
|
+
*
|
|
986
2174
|
* Version-tolerant snapshot/results for the run's post-run checks.
|
|
987
2175
|
*/
|
|
988
2176
|
post_run_checks?: Array<RunPostRunCheckSnapshot> | null;
|
|
2177
|
+
/**
|
|
2178
|
+
* Session Id
|
|
2179
|
+
*/
|
|
989
2180
|
session_id?: string | null;
|
|
2181
|
+
/**
|
|
2182
|
+
* Session Alias
|
|
2183
|
+
*/
|
|
990
2184
|
session_alias?: string | null;
|
|
2185
|
+
/**
|
|
2186
|
+
* Release Session After
|
|
2187
|
+
*/
|
|
991
2188
|
release_session_after?: boolean | null;
|
|
2189
|
+
/**
|
|
2190
|
+
* Created At
|
|
2191
|
+
*/
|
|
992
2192
|
created_at: string;
|
|
2193
|
+
/**
|
|
2194
|
+
* Started At
|
|
2195
|
+
*/
|
|
993
2196
|
started_at?: string | null;
|
|
2197
|
+
/**
|
|
2198
|
+
* Ended At
|
|
2199
|
+
*/
|
|
994
2200
|
ended_at?: string | null;
|
|
995
2201
|
};
|
|
996
2202
|
/**
|
|
2203
|
+
* RunResponseWithIncludes
|
|
2204
|
+
*
|
|
997
2205
|
* Run response with optional included related resources.
|
|
998
2206
|
*
|
|
999
2207
|
* When the `include` query parameter is used, related resources are returned
|
|
@@ -1002,50 +2210,115 @@ export type RunResponseOutput = {
|
|
|
1002
2210
|
* Example request: GET /v1/runs/123?include=workflow,machine
|
|
1003
2211
|
*/
|
|
1004
2212
|
export type RunResponseWithIncludes = {
|
|
2213
|
+
/**
|
|
2214
|
+
* Id
|
|
2215
|
+
*/
|
|
1005
2216
|
id: string;
|
|
2217
|
+
/**
|
|
2218
|
+
* Workflow Id
|
|
2219
|
+
*/
|
|
1006
2220
|
workflow_id: string;
|
|
2221
|
+
/**
|
|
2222
|
+
* Machine Id
|
|
2223
|
+
*/
|
|
1007
2224
|
machine_id?: string | null;
|
|
2225
|
+
/**
|
|
2226
|
+
* User Id
|
|
2227
|
+
*/
|
|
1008
2228
|
user_id?: string | null;
|
|
2229
|
+
/**
|
|
2230
|
+
* Organization Id
|
|
2231
|
+
*/
|
|
1009
2232
|
organization_id?: string | null;
|
|
1010
2233
|
status: RunStatus;
|
|
2234
|
+
/**
|
|
2235
|
+
* Error
|
|
2236
|
+
*/
|
|
1011
2237
|
error?: Array<string> | null;
|
|
2238
|
+
/**
|
|
2239
|
+
* Output Data
|
|
2240
|
+
*/
|
|
1012
2241
|
output_data?: {
|
|
1013
2242
|
[key: string]: unknown;
|
|
1014
2243
|
} | null;
|
|
2244
|
+
/**
|
|
2245
|
+
* Input Attachment Ids
|
|
2246
|
+
*/
|
|
1015
2247
|
input_attachment_ids?: Array<string> | null;
|
|
2248
|
+
/**
|
|
2249
|
+
* Output Attachment Ids
|
|
2250
|
+
*/
|
|
1016
2251
|
output_attachment_ids?: Array<string> | null;
|
|
2252
|
+
/**
|
|
2253
|
+
* Run Message History
|
|
2254
|
+
*/
|
|
1017
2255
|
run_message_history?: Array<{
|
|
1018
2256
|
[key: string]: unknown;
|
|
1019
2257
|
}> | null;
|
|
2258
|
+
/**
|
|
2259
|
+
* Input Values
|
|
2260
|
+
*/
|
|
1020
2261
|
input_values?: {
|
|
1021
2262
|
[key: string]: unknown;
|
|
1022
2263
|
} | null;
|
|
2264
|
+
/**
|
|
2265
|
+
* Pool Ids
|
|
2266
|
+
*/
|
|
1023
2267
|
pool_ids?: Array<string> | null;
|
|
2268
|
+
/**
|
|
2269
|
+
* Sensitive Input Aliases
|
|
2270
|
+
*/
|
|
1024
2271
|
sensitive_input_aliases?: {
|
|
1025
2272
|
[key: string]: string;
|
|
1026
2273
|
} | null;
|
|
1027
2274
|
/**
|
|
2275
|
+
* Usage Metadata
|
|
2276
|
+
*
|
|
1028
2277
|
* Arbitrary usage/billing metadata captured during a run
|
|
1029
2278
|
*/
|
|
1030
2279
|
usage_metadata?: {
|
|
1031
2280
|
[key: string]: unknown;
|
|
1032
2281
|
} | null;
|
|
1033
2282
|
/**
|
|
2283
|
+
* Post Run Checks
|
|
2284
|
+
*
|
|
1034
2285
|
* Version-tolerant snapshot/results for the run's post-run checks.
|
|
1035
2286
|
*/
|
|
1036
2287
|
post_run_checks?: Array<RunPostRunCheckSnapshot> | null;
|
|
2288
|
+
/**
|
|
2289
|
+
* Session Id
|
|
2290
|
+
*/
|
|
1037
2291
|
session_id?: string | null;
|
|
2292
|
+
/**
|
|
2293
|
+
* Session Alias
|
|
2294
|
+
*/
|
|
1038
2295
|
session_alias?: string | null;
|
|
2296
|
+
/**
|
|
2297
|
+
* Release Session After
|
|
2298
|
+
*/
|
|
1039
2299
|
release_session_after?: boolean | null;
|
|
2300
|
+
/**
|
|
2301
|
+
* Created At
|
|
2302
|
+
*/
|
|
1040
2303
|
created_at: string;
|
|
2304
|
+
/**
|
|
2305
|
+
* Started At
|
|
2306
|
+
*/
|
|
1041
2307
|
started_at?: string | null;
|
|
2308
|
+
/**
|
|
2309
|
+
* Ended At
|
|
2310
|
+
*/
|
|
1042
2311
|
ended_at?: string | null;
|
|
1043
2312
|
/**
|
|
2313
|
+
* Included
|
|
2314
|
+
*
|
|
1044
2315
|
* Related resources requested via the `include` query parameter
|
|
1045
2316
|
*/
|
|
1046
2317
|
included?: Array<IncludedResource> | null;
|
|
1047
2318
|
};
|
|
1048
2319
|
/**
|
|
2320
|
+
* RunRetry
|
|
2321
|
+
*
|
|
1049
2322
|
* Options for retrying an existing run in-place (same run_id).
|
|
1050
2323
|
*
|
|
1051
2324
|
* Notes:
|
|
@@ -1055,76 +2328,133 @@ export type RunResponseWithIncludes = {
|
|
|
1055
2328
|
*/
|
|
1056
2329
|
export type RunRetry = {
|
|
1057
2330
|
/**
|
|
2331
|
+
* Input Values
|
|
2332
|
+
*
|
|
1058
2333
|
* Override input values for workflow variables
|
|
1059
2334
|
*/
|
|
1060
2335
|
input_values?: {
|
|
1061
2336
|
[key: string]: unknown;
|
|
1062
2337
|
} | null;
|
|
1063
2338
|
/**
|
|
2339
|
+
* Sensitive Input Values
|
|
2340
|
+
*
|
|
1064
2341
|
* Provide new sensitive inputs (supports nested objects); stored in vault and mapped to aliases
|
|
1065
2342
|
*/
|
|
1066
2343
|
sensitive_input_values?: {
|
|
1067
2344
|
[key: string]: unknown;
|
|
1068
2345
|
} | null;
|
|
1069
2346
|
/**
|
|
2347
|
+
* File Inputs
|
|
2348
|
+
*
|
|
1070
2349
|
* Provide new input files for this retry; replaces existing input attachments
|
|
1071
2350
|
*/
|
|
1072
2351
|
file_inputs?: Array<FileInput> | null;
|
|
1073
2352
|
/**
|
|
2353
|
+
* Machine Id
|
|
2354
|
+
*
|
|
1074
2355
|
* Override specific machine for this retry
|
|
1075
2356
|
*/
|
|
1076
2357
|
machine_id?: string | null;
|
|
1077
2358
|
/**
|
|
2359
|
+
* Pool Ids
|
|
2360
|
+
*
|
|
1078
2361
|
* Override pool filters if not using a specific machine
|
|
1079
2362
|
*/
|
|
1080
2363
|
pool_ids?: Array<string> | null;
|
|
1081
2364
|
/**
|
|
2365
|
+
* Reuse Session
|
|
2366
|
+
*
|
|
1082
2367
|
* Keep existing session_id. If false and no session_id provided, clears session fields
|
|
1083
2368
|
*/
|
|
1084
2369
|
reuse_session?: boolean | null;
|
|
1085
2370
|
/**
|
|
2371
|
+
* Session Id
|
|
2372
|
+
*
|
|
1086
2373
|
* Set/override session_id for this retry
|
|
1087
2374
|
*/
|
|
1088
2375
|
session_id?: string | null;
|
|
1089
2376
|
/**
|
|
2377
|
+
* Start Session
|
|
2378
|
+
*
|
|
1090
2379
|
* Start a fresh new session for this retry (creates new session_id)
|
|
1091
2380
|
*/
|
|
1092
2381
|
start_session?: boolean | null;
|
|
1093
2382
|
/**
|
|
2383
|
+
* Session Alias
|
|
2384
|
+
*
|
|
1094
2385
|
* Set/override session_alias for this retry (used with start_session or session_id)
|
|
1095
2386
|
*/
|
|
1096
2387
|
session_alias?: string | null;
|
|
1097
2388
|
/**
|
|
2389
|
+
* Release Session After
|
|
2390
|
+
*
|
|
1098
2391
|
* Override release_session_after behavior for this retry
|
|
1099
2392
|
*/
|
|
1100
2393
|
release_session_after?: boolean | null;
|
|
1101
2394
|
};
|
|
2395
|
+
/**
|
|
2396
|
+
* RunStatus
|
|
2397
|
+
*/
|
|
1102
2398
|
export type RunStatus = 'scheduling' | 'running' | 'running_checks' | 'success' | 'cancelled' | 'task_failed' | 'error';
|
|
1103
2399
|
/**
|
|
2400
|
+
* RunUpdate
|
|
2401
|
+
*
|
|
1104
2402
|
* Schema for updating a run
|
|
1105
2403
|
*/
|
|
1106
2404
|
export type RunUpdate = {
|
|
1107
2405
|
status?: RunStatus | null;
|
|
2406
|
+
/**
|
|
2407
|
+
* Error
|
|
2408
|
+
*/
|
|
1108
2409
|
error?: Array<string> | null;
|
|
2410
|
+
/**
|
|
2411
|
+
* Output Data
|
|
2412
|
+
*/
|
|
1109
2413
|
output_data?: {
|
|
1110
2414
|
[key: string]: unknown;
|
|
1111
2415
|
} | null;
|
|
2416
|
+
/**
|
|
2417
|
+
* Output Attachment Ids
|
|
2418
|
+
*/
|
|
1112
2419
|
output_attachment_ids?: Array<string> | null;
|
|
2420
|
+
/**
|
|
2421
|
+
* Run Message History
|
|
2422
|
+
*/
|
|
1113
2423
|
run_message_history?: Array<{
|
|
1114
2424
|
[key: string]: unknown;
|
|
1115
2425
|
}> | null;
|
|
2426
|
+
/**
|
|
2427
|
+
* Input Values
|
|
2428
|
+
*/
|
|
1116
2429
|
input_values?: {
|
|
1117
2430
|
[key: string]: unknown;
|
|
1118
2431
|
} | null;
|
|
2432
|
+
/**
|
|
2433
|
+
* Usage Metadata
|
|
2434
|
+
*/
|
|
1119
2435
|
usage_metadata?: {
|
|
1120
2436
|
[key: string]: unknown;
|
|
1121
2437
|
} | null;
|
|
2438
|
+
/**
|
|
2439
|
+
* Post Run Checks
|
|
2440
|
+
*/
|
|
1122
2441
|
post_run_checks?: Array<RunPostRunCheckSnapshot> | null;
|
|
2442
|
+
/**
|
|
2443
|
+
* Started At
|
|
2444
|
+
*/
|
|
1123
2445
|
started_at?: string | null;
|
|
2446
|
+
/**
|
|
2447
|
+
* Ended At
|
|
2448
|
+
*/
|
|
1124
2449
|
ended_at?: string | null;
|
|
2450
|
+
/**
|
|
2451
|
+
* Release Session After
|
|
2452
|
+
*/
|
|
1125
2453
|
release_session_after?: boolean | null;
|
|
1126
2454
|
};
|
|
1127
2455
|
/**
|
|
2456
|
+
* TrajectoryCreate
|
|
2457
|
+
*
|
|
1128
2458
|
* Schema for creating a trajectory.
|
|
1129
2459
|
*
|
|
1130
2460
|
* Note: `is_generated` is intentionally omitted here. New trajectories always
|
|
@@ -1132,189 +2462,392 @@ export type RunUpdate = {
|
|
|
1132
2462
|
* POST /runs/{run_id}/generate-trajectory.
|
|
1133
2463
|
*/
|
|
1134
2464
|
export type TrajectoryCreate = {
|
|
2465
|
+
/**
|
|
2466
|
+
* Name
|
|
2467
|
+
*/
|
|
1135
2468
|
name?: string | null;
|
|
2469
|
+
/**
|
|
2470
|
+
* Description
|
|
2471
|
+
*/
|
|
1136
2472
|
description?: string | null;
|
|
2473
|
+
/**
|
|
2474
|
+
* Workflow Id
|
|
2475
|
+
*/
|
|
1137
2476
|
workflow_id: string;
|
|
1138
2477
|
/**
|
|
2478
|
+
* Run Id
|
|
2479
|
+
*
|
|
1139
2480
|
* Optional run that created this trajectory
|
|
1140
2481
|
*/
|
|
1141
2482
|
run_id?: string | null;
|
|
2483
|
+
/**
|
|
2484
|
+
* Trajectory Data
|
|
2485
|
+
*/
|
|
1142
2486
|
trajectory_data: Array<{
|
|
1143
2487
|
[key: string]: unknown;
|
|
1144
2488
|
}>;
|
|
1145
2489
|
/**
|
|
2490
|
+
* Dimensions
|
|
2491
|
+
*
|
|
1146
2492
|
* Display dimensions when trajectory was recorded
|
|
1147
2493
|
*/
|
|
1148
2494
|
dimensions: {
|
|
1149
2495
|
[key: string]: number;
|
|
1150
2496
|
};
|
|
1151
2497
|
/**
|
|
2498
|
+
* Original Input Values
|
|
2499
|
+
*
|
|
1152
2500
|
* Original input values used when trajectory was created
|
|
1153
2501
|
*/
|
|
1154
2502
|
original_input_values?: {
|
|
1155
2503
|
[key: string]: unknown;
|
|
1156
2504
|
} | null;
|
|
1157
2505
|
/**
|
|
2506
|
+
* Is Approved
|
|
2507
|
+
*
|
|
1158
2508
|
* Whether this trajectory is approved for use
|
|
1159
2509
|
*/
|
|
1160
2510
|
is_approved?: boolean;
|
|
1161
2511
|
};
|
|
1162
2512
|
/**
|
|
2513
|
+
* TrajectoryResponse
|
|
2514
|
+
*
|
|
1163
2515
|
* Trajectory response schema
|
|
1164
2516
|
*/
|
|
1165
2517
|
export type TrajectoryResponse = {
|
|
2518
|
+
/**
|
|
2519
|
+
* Name
|
|
2520
|
+
*/
|
|
1166
2521
|
name?: string | null;
|
|
2522
|
+
/**
|
|
2523
|
+
* Description
|
|
2524
|
+
*/
|
|
1167
2525
|
description?: string | null;
|
|
2526
|
+
/**
|
|
2527
|
+
* Workflow Id
|
|
2528
|
+
*/
|
|
1168
2529
|
workflow_id: string;
|
|
1169
2530
|
/**
|
|
2531
|
+
* Run Id
|
|
2532
|
+
*
|
|
1170
2533
|
* Optional run that created this trajectory
|
|
1171
2534
|
*/
|
|
1172
2535
|
run_id?: string | null;
|
|
2536
|
+
/**
|
|
2537
|
+
* Trajectory Data
|
|
2538
|
+
*/
|
|
1173
2539
|
trajectory_data: Array<{
|
|
1174
2540
|
[key: string]: unknown;
|
|
1175
2541
|
}>;
|
|
1176
2542
|
/**
|
|
2543
|
+
* Dimensions
|
|
2544
|
+
*
|
|
1177
2545
|
* Display dimensions when trajectory was recorded
|
|
1178
2546
|
*/
|
|
1179
2547
|
dimensions: {
|
|
1180
2548
|
[key: string]: number;
|
|
1181
2549
|
};
|
|
1182
2550
|
/**
|
|
2551
|
+
* Original Input Values
|
|
2552
|
+
*
|
|
1183
2553
|
* Original input values used when trajectory was created
|
|
1184
2554
|
*/
|
|
1185
2555
|
original_input_values?: {
|
|
1186
2556
|
[key: string]: unknown;
|
|
1187
2557
|
} | null;
|
|
2558
|
+
/**
|
|
2559
|
+
* Is Approved
|
|
2560
|
+
*/
|
|
1188
2561
|
is_approved: boolean;
|
|
2562
|
+
/**
|
|
2563
|
+
* Is Generated
|
|
2564
|
+
*/
|
|
1189
2565
|
is_generated: boolean;
|
|
2566
|
+
/**
|
|
2567
|
+
* Id
|
|
2568
|
+
*/
|
|
1190
2569
|
id: string;
|
|
2570
|
+
/**
|
|
2571
|
+
* User Id
|
|
2572
|
+
*/
|
|
1191
2573
|
user_id?: string | null;
|
|
2574
|
+
/**
|
|
2575
|
+
* Organization Id
|
|
2576
|
+
*/
|
|
1192
2577
|
organization_id?: string | null;
|
|
2578
|
+
/**
|
|
2579
|
+
* Created At
|
|
2580
|
+
*/
|
|
1193
2581
|
created_at: string;
|
|
2582
|
+
/**
|
|
2583
|
+
* Updated At
|
|
2584
|
+
*/
|
|
1194
2585
|
updated_at: string;
|
|
1195
2586
|
};
|
|
1196
2587
|
/**
|
|
2588
|
+
* TrajectoryResponseWithIncludes
|
|
2589
|
+
*
|
|
1197
2590
|
* Trajectory response with optional included related resources.
|
|
1198
2591
|
*/
|
|
1199
2592
|
export type TrajectoryResponseWithIncludes = {
|
|
2593
|
+
/**
|
|
2594
|
+
* Id
|
|
2595
|
+
*/
|
|
1200
2596
|
id: string;
|
|
2597
|
+
/**
|
|
2598
|
+
* Workflow Id
|
|
2599
|
+
*/
|
|
1201
2600
|
workflow_id: string;
|
|
2601
|
+
/**
|
|
2602
|
+
* Run Id
|
|
2603
|
+
*/
|
|
1202
2604
|
run_id?: string | null;
|
|
2605
|
+
/**
|
|
2606
|
+
* User Id
|
|
2607
|
+
*/
|
|
1203
2608
|
user_id?: string | null;
|
|
2609
|
+
/**
|
|
2610
|
+
* Organization Id
|
|
2611
|
+
*/
|
|
1204
2612
|
organization_id?: string | null;
|
|
2613
|
+
/**
|
|
2614
|
+
* Name
|
|
2615
|
+
*/
|
|
1205
2616
|
name?: string | null;
|
|
2617
|
+
/**
|
|
2618
|
+
* Description
|
|
2619
|
+
*/
|
|
1206
2620
|
description?: string | null;
|
|
2621
|
+
/**
|
|
2622
|
+
* Is Approved
|
|
2623
|
+
*/
|
|
1207
2624
|
is_approved: boolean;
|
|
2625
|
+
/**
|
|
2626
|
+
* Is Generated
|
|
2627
|
+
*/
|
|
1208
2628
|
is_generated: boolean;
|
|
2629
|
+
/**
|
|
2630
|
+
* Trajectory Data
|
|
2631
|
+
*/
|
|
1209
2632
|
trajectory_data?: Array<{
|
|
1210
2633
|
[key: string]: unknown;
|
|
1211
2634
|
}> | null;
|
|
1212
2635
|
/**
|
|
2636
|
+
* Dimensions
|
|
2637
|
+
*
|
|
1213
2638
|
* Display dimensions when trajectory was recorded
|
|
1214
2639
|
*/
|
|
1215
2640
|
dimensions: {
|
|
1216
2641
|
[key: string]: number;
|
|
1217
2642
|
};
|
|
1218
2643
|
/**
|
|
2644
|
+
* Original Input Values
|
|
2645
|
+
*
|
|
1219
2646
|
* Original input values used when trajectory was created
|
|
1220
2647
|
*/
|
|
1221
2648
|
original_input_values?: {
|
|
1222
2649
|
[key: string]: unknown;
|
|
1223
2650
|
} | null;
|
|
2651
|
+
/**
|
|
2652
|
+
* Created At
|
|
2653
|
+
*/
|
|
1224
2654
|
created_at: string;
|
|
2655
|
+
/**
|
|
2656
|
+
* Updated At
|
|
2657
|
+
*/
|
|
1225
2658
|
updated_at: string;
|
|
1226
2659
|
/**
|
|
2660
|
+
* Included
|
|
2661
|
+
*
|
|
1227
2662
|
* Related resources requested via the `include` query parameter
|
|
1228
2663
|
*/
|
|
1229
2664
|
included?: Array<IncludedResource> | null;
|
|
1230
2665
|
};
|
|
1231
2666
|
/**
|
|
2667
|
+
* TrajectoryUpdate
|
|
2668
|
+
*
|
|
1232
2669
|
* Schema for updating a trajectory
|
|
1233
2670
|
*/
|
|
1234
2671
|
export type TrajectoryUpdate = {
|
|
2672
|
+
/**
|
|
2673
|
+
* Name
|
|
2674
|
+
*/
|
|
1235
2675
|
name?: string | null;
|
|
2676
|
+
/**
|
|
2677
|
+
* Description
|
|
2678
|
+
*/
|
|
1236
2679
|
description?: string | null;
|
|
2680
|
+
/**
|
|
2681
|
+
* Trajectory Data
|
|
2682
|
+
*/
|
|
1237
2683
|
trajectory_data?: Array<{
|
|
1238
2684
|
[key: string]: unknown;
|
|
1239
2685
|
}> | null;
|
|
1240
2686
|
/**
|
|
2687
|
+
* Is Approved
|
|
2688
|
+
*
|
|
1241
2689
|
* Whether this trajectory is approved for use
|
|
1242
2690
|
*/
|
|
1243
2691
|
is_approved?: boolean | null;
|
|
1244
2692
|
};
|
|
1245
2693
|
/**
|
|
2694
|
+
* UsageAggregateResponse
|
|
2695
|
+
*
|
|
1246
2696
|
* Response schema for usage aggregation.
|
|
1247
2697
|
*/
|
|
1248
2698
|
export type UsageAggregateResponse = {
|
|
2699
|
+
/**
|
|
2700
|
+
* Total Agentic Steps
|
|
2701
|
+
*/
|
|
1249
2702
|
total_agentic_steps: number;
|
|
2703
|
+
/**
|
|
2704
|
+
* Total Cached Steps
|
|
2705
|
+
*/
|
|
1250
2706
|
total_cached_steps: number;
|
|
2707
|
+
/**
|
|
2708
|
+
* Period Start
|
|
2709
|
+
*/
|
|
1251
2710
|
period_start: string;
|
|
2711
|
+
/**
|
|
2712
|
+
* Period End
|
|
2713
|
+
*/
|
|
1252
2714
|
period_end: string;
|
|
1253
2715
|
mode: UsageMode;
|
|
2716
|
+
/**
|
|
2717
|
+
* Runs Counted
|
|
2718
|
+
*/
|
|
1254
2719
|
runs_counted: number;
|
|
1255
2720
|
};
|
|
1256
2721
|
/**
|
|
2722
|
+
* UsageMode
|
|
2723
|
+
*
|
|
1257
2724
|
* Mode for counting usage steps.
|
|
1258
2725
|
*/
|
|
1259
2726
|
export type UsageMode = 'simulated' | 'billed';
|
|
2727
|
+
/**
|
|
2728
|
+
* ValidationError
|
|
2729
|
+
*/
|
|
1260
2730
|
export type ValidationError = {
|
|
2731
|
+
/**
|
|
2732
|
+
* Location
|
|
2733
|
+
*/
|
|
1261
2734
|
loc: Array<string | number>;
|
|
2735
|
+
/**
|
|
2736
|
+
* Message
|
|
2737
|
+
*/
|
|
1262
2738
|
msg: string;
|
|
2739
|
+
/**
|
|
2740
|
+
* Error Type
|
|
2741
|
+
*/
|
|
1263
2742
|
type: string;
|
|
2743
|
+
/**
|
|
2744
|
+
* Input
|
|
2745
|
+
*/
|
|
1264
2746
|
input?: unknown;
|
|
2747
|
+
/**
|
|
2748
|
+
* Context
|
|
2749
|
+
*/
|
|
1265
2750
|
ctx?: {
|
|
1266
2751
|
[key: string]: unknown;
|
|
1267
2752
|
};
|
|
1268
2753
|
};
|
|
1269
2754
|
/**
|
|
2755
|
+
* WorkflowChainCreate
|
|
2756
|
+
*
|
|
1270
2757
|
* Request to create and run a multi-step chain on a single reserved session/machine
|
|
1271
2758
|
*/
|
|
1272
2759
|
export type WorkflowChainCreate = {
|
|
2760
|
+
/**
|
|
2761
|
+
* Steps
|
|
2762
|
+
*/
|
|
1273
2763
|
steps: Array<ChainStep>;
|
|
2764
|
+
/**
|
|
2765
|
+
* Shared Inputs
|
|
2766
|
+
*/
|
|
1274
2767
|
shared_inputs?: {
|
|
1275
2768
|
[key: string]: unknown;
|
|
1276
2769
|
} | null;
|
|
1277
2770
|
/**
|
|
2771
|
+
* Shared Sensitive Inputs
|
|
2772
|
+
*
|
|
1278
2773
|
* Shared sensitive inputs (supports nested objects) for all steps
|
|
1279
2774
|
*/
|
|
1280
2775
|
shared_sensitive_inputs?: {
|
|
1281
2776
|
[key: string]: unknown;
|
|
1282
2777
|
} | null;
|
|
2778
|
+
/**
|
|
2779
|
+
* Shared File Inputs
|
|
2780
|
+
*/
|
|
1283
2781
|
shared_file_inputs?: Array<FileInput> | null;
|
|
2782
|
+
/**
|
|
2783
|
+
* Keep Session After Completion
|
|
2784
|
+
*/
|
|
1284
2785
|
keep_session_after_completion?: boolean | null;
|
|
2786
|
+
/**
|
|
2787
|
+
* Machine Id
|
|
2788
|
+
*/
|
|
1285
2789
|
machine_id?: string | null;
|
|
1286
2790
|
/**
|
|
2791
|
+
* Pool Ids
|
|
2792
|
+
*
|
|
1287
2793
|
* Pool IDs to filter available machines when starting a new session. Machine must belong to ALL of these pools (intersection). Ignored when machine_id is provided.
|
|
1288
2794
|
*/
|
|
1289
2795
|
pool_ids?: Array<string> | null;
|
|
2796
|
+
/**
|
|
2797
|
+
* Session Id
|
|
2798
|
+
*/
|
|
1290
2799
|
session_id?: string | null;
|
|
1291
2800
|
};
|
|
1292
2801
|
/**
|
|
2802
|
+
* WorkflowChainResponse
|
|
2803
|
+
*
|
|
1293
2804
|
* Response for chain creation
|
|
1294
2805
|
*/
|
|
1295
2806
|
export type WorkflowChainResponse = {
|
|
2807
|
+
/**
|
|
2808
|
+
* Session Id
|
|
2809
|
+
*/
|
|
1296
2810
|
session_id: string;
|
|
2811
|
+
/**
|
|
2812
|
+
* Run Ids
|
|
2813
|
+
*/
|
|
1297
2814
|
run_ids: Array<string>;
|
|
1298
2815
|
};
|
|
1299
2816
|
/**
|
|
2817
|
+
* WorkflowCreate
|
|
2818
|
+
*
|
|
1300
2819
|
* Schema for creating a workflow
|
|
1301
2820
|
*/
|
|
1302
2821
|
export type WorkflowCreate = {
|
|
2822
|
+
/**
|
|
2823
|
+
* Name
|
|
2824
|
+
*/
|
|
1303
2825
|
name?: string | null;
|
|
2826
|
+
/**
|
|
2827
|
+
* Main Prompt
|
|
2828
|
+
*/
|
|
1304
2829
|
main_prompt: string;
|
|
1305
2830
|
/**
|
|
2831
|
+
* Input Schema
|
|
2832
|
+
*
|
|
1306
2833
|
* JSON schema for validating merged run inputs. Sensitive root keys are exposed with a '$' prefix in schema validation (for example sensitive_input_values.api_key -> '$api_key').
|
|
1307
2834
|
*/
|
|
1308
2835
|
input_schema?: string | null;
|
|
1309
2836
|
/**
|
|
2837
|
+
* Output Schema
|
|
2838
|
+
*
|
|
1310
2839
|
* JSON schema for output data transformation
|
|
1311
2840
|
*/
|
|
1312
2841
|
output_schema?: string | null;
|
|
1313
2842
|
/**
|
|
2843
|
+
* Includes File Exports
|
|
2844
|
+
*
|
|
1314
2845
|
* Enable AI-based file export detection
|
|
1315
2846
|
*/
|
|
1316
2847
|
includes_file_exports?: boolean;
|
|
1317
2848
|
/**
|
|
2849
|
+
* Is Webhooks Enabled
|
|
2850
|
+
*
|
|
1318
2851
|
* Send webhook on run completion
|
|
1319
2852
|
*/
|
|
1320
2853
|
is_webhooks_enabled?: boolean;
|
|
@@ -1323,67 +2856,97 @@ export type WorkflowCreate = {
|
|
|
1323
2856
|
*/
|
|
1324
2857
|
model_metadata?: WorkflowModelMetadata | null;
|
|
1325
2858
|
/**
|
|
2859
|
+
* Post Run Checks
|
|
2860
|
+
*
|
|
1326
2861
|
* Workflow-managed post-run checks, reconciled on save.
|
|
1327
2862
|
*/
|
|
1328
2863
|
post_run_checks?: Array<WorkflowPostRunCheckUpsert> | null;
|
|
1329
2864
|
};
|
|
1330
2865
|
/**
|
|
2866
|
+
* WorkflowDuplicateRequest
|
|
2867
|
+
*
|
|
1331
2868
|
* Schema for duplicating workflows.
|
|
1332
2869
|
*/
|
|
1333
2870
|
export type WorkflowDuplicateRequest = {
|
|
1334
2871
|
/**
|
|
2872
|
+
* Include Trajectories
|
|
2873
|
+
*
|
|
1335
2874
|
* Whether to duplicate generated trajectories onto the copied workflow. Non-generated trajectories are never duplicated.
|
|
1336
2875
|
*/
|
|
1337
2876
|
include_trajectories?: boolean;
|
|
1338
2877
|
};
|
|
1339
2878
|
/**
|
|
2879
|
+
* WorkflowInternalMetadata
|
|
2880
|
+
*
|
|
1340
2881
|
* Backend workflow metadata exposed read-only for internal observability.
|
|
1341
2882
|
*/
|
|
1342
2883
|
export type WorkflowInternalMetadata = {
|
|
1343
2884
|
/**
|
|
2885
|
+
* Has Unaddressed Error
|
|
2886
|
+
*
|
|
1344
2887
|
* True when at least one run has failed and remains unaddressed.
|
|
1345
2888
|
*/
|
|
1346
2889
|
has_unaddressed_error?: boolean | null;
|
|
1347
2890
|
/**
|
|
2891
|
+
* Last Errored Run Start
|
|
2892
|
+
*
|
|
1348
2893
|
* Start timestamp of the most recent errored/task_failed run.
|
|
1349
2894
|
*/
|
|
1350
2895
|
last_errored_run_start?: string | null;
|
|
1351
2896
|
/**
|
|
2897
|
+
* Last Errored Run Uuid
|
|
2898
|
+
*
|
|
1352
2899
|
* Run UUID of the most recent errored/task_failed run.
|
|
1353
2900
|
*/
|
|
1354
2901
|
last_errored_run_uuid?: string | null;
|
|
1355
2902
|
};
|
|
1356
2903
|
/**
|
|
2904
|
+
* WorkflowInternalMetadataUpdate
|
|
2905
|
+
*
|
|
1357
2906
|
* Patchable workflow metadata fields for internal workflow maintenance.
|
|
1358
2907
|
*/
|
|
1359
2908
|
export type WorkflowInternalMetadataUpdate = {
|
|
1360
2909
|
/**
|
|
2910
|
+
* Has Unaddressed Error
|
|
2911
|
+
*
|
|
1361
2912
|
* Set to false when workflow errors have been addressed.
|
|
1362
2913
|
*/
|
|
1363
2914
|
has_unaddressed_error?: boolean | null;
|
|
1364
2915
|
/**
|
|
2916
|
+
* Last Errored Run Start
|
|
2917
|
+
*
|
|
1365
2918
|
* Start timestamp of the most recent errored/task_failed run.
|
|
1366
2919
|
*/
|
|
1367
2920
|
last_errored_run_start?: string | null;
|
|
1368
2921
|
/**
|
|
2922
|
+
* Last Errored Run Uuid
|
|
2923
|
+
*
|
|
1369
2924
|
* Run UUID of the most recent errored/task_failed run.
|
|
1370
2925
|
*/
|
|
1371
2926
|
last_errored_run_uuid?: string | null;
|
|
1372
2927
|
};
|
|
1373
2928
|
/**
|
|
2929
|
+
* WorkflowMergeRequest
|
|
2930
|
+
*
|
|
1374
2931
|
* Schema for merging workflows
|
|
1375
2932
|
*/
|
|
1376
2933
|
export type WorkflowMergeRequest = {
|
|
1377
2934
|
/**
|
|
2935
|
+
* Target Workflow Id
|
|
2936
|
+
*
|
|
1378
2937
|
* Workflow ID to merge into
|
|
1379
2938
|
*/
|
|
1380
2939
|
target_workflow_id: string;
|
|
1381
2940
|
/**
|
|
2941
|
+
* Copy Trajectories
|
|
2942
|
+
*
|
|
1382
2943
|
* Whether to copy trajectories to the target workflow
|
|
1383
2944
|
*/
|
|
1384
2945
|
copy_trajectories?: boolean;
|
|
1385
2946
|
};
|
|
1386
2947
|
/**
|
|
2948
|
+
* WorkflowModelMetadata
|
|
2949
|
+
*
|
|
1387
2950
|
* JSONB-backed workflow model configuration metadata.
|
|
1388
2951
|
*
|
|
1389
2952
|
* Stored on the Workflow row as `model_metadata` to avoid adding many FK columns.
|
|
@@ -1391,155 +2954,294 @@ export type WorkflowMergeRequest = {
|
|
|
1391
2954
|
*/
|
|
1392
2955
|
export type WorkflowModelMetadata = {
|
|
1393
2956
|
/**
|
|
2957
|
+
* Main Agent Model Id
|
|
2958
|
+
*
|
|
1394
2959
|
* ModelConfiguration.id used for the main agent. Null → Cyberdesk default.
|
|
1395
2960
|
*/
|
|
1396
2961
|
main_agent_model_id?: string | null;
|
|
1397
2962
|
/**
|
|
2963
|
+
* Cache Detection Model Id
|
|
2964
|
+
*
|
|
1398
2965
|
* ModelConfiguration.id used for cache detection. Null → Cyberdesk default.
|
|
1399
2966
|
*/
|
|
1400
2967
|
cache_detection_model_id?: string | null;
|
|
1401
2968
|
/**
|
|
2969
|
+
* Fallback Model 1 Id
|
|
2970
|
+
*
|
|
1402
2971
|
* ModelConfiguration.id used as fallback 1 (global across agents).
|
|
1403
2972
|
*/
|
|
1404
2973
|
fallback_model_1_id?: string | null;
|
|
1405
2974
|
/**
|
|
2975
|
+
* Fallback Model 2 Id
|
|
2976
|
+
*
|
|
1406
2977
|
* ModelConfiguration.id used as fallback 2 (global across agents).
|
|
1407
2978
|
*/
|
|
1408
2979
|
fallback_model_2_id?: string | null;
|
|
1409
2980
|
};
|
|
1410
2981
|
/**
|
|
2982
|
+
* WorkflowPostRunCheckResponse
|
|
2983
|
+
*
|
|
1411
2984
|
* Workflow response shape for post-run checks, including workflow-specific order.
|
|
1412
2985
|
*/
|
|
1413
2986
|
export type WorkflowPostRunCheckResponse = {
|
|
2987
|
+
/**
|
|
2988
|
+
* Name
|
|
2989
|
+
*/
|
|
1414
2990
|
name: string;
|
|
2991
|
+
/**
|
|
2992
|
+
* Description
|
|
2993
|
+
*/
|
|
1415
2994
|
description?: string | null;
|
|
1416
2995
|
type: PostRunCheckType;
|
|
1417
2996
|
file_target_mode?: PostRunCheckFileTargetMode | null;
|
|
2997
|
+
/**
|
|
2998
|
+
* File Names
|
|
2999
|
+
*/
|
|
1418
3000
|
file_names?: Array<string> | null;
|
|
3001
|
+
/**
|
|
3002
|
+
* File Name Regex
|
|
3003
|
+
*/
|
|
1419
3004
|
file_name_regex?: string | null;
|
|
3005
|
+
/**
|
|
3006
|
+
* Expected Match Count
|
|
3007
|
+
*/
|
|
1420
3008
|
expected_match_count?: number | null;
|
|
3009
|
+
/**
|
|
3010
|
+
* Expected Match Count Ref
|
|
3011
|
+
*/
|
|
1421
3012
|
expected_match_count_ref?: string | null;
|
|
3013
|
+
/**
|
|
3014
|
+
* Loop Input
|
|
3015
|
+
*/
|
|
1422
3016
|
loop_input?: string | null;
|
|
3017
|
+
/**
|
|
3018
|
+
* Loop Item Filename Template
|
|
3019
|
+
*/
|
|
1423
3020
|
loop_item_filename_template?: string | null;
|
|
3021
|
+
/**
|
|
3022
|
+
* Check Prompt
|
|
3023
|
+
*/
|
|
1424
3024
|
check_prompt?: string | null;
|
|
1425
3025
|
/**
|
|
3026
|
+
* Model
|
|
3027
|
+
*
|
|
1426
3028
|
* Optional ModelConfiguration id override for agentic post-run checks.
|
|
1427
3029
|
*/
|
|
1428
3030
|
model?: string | null;
|
|
3031
|
+
/**
|
|
3032
|
+
* Id
|
|
3033
|
+
*/
|
|
1429
3034
|
id: string;
|
|
3035
|
+
/**
|
|
3036
|
+
* Organization Id
|
|
3037
|
+
*/
|
|
1430
3038
|
organization_id: string;
|
|
3039
|
+
/**
|
|
3040
|
+
* User Id
|
|
3041
|
+
*/
|
|
1431
3042
|
user_id?: string | null;
|
|
3043
|
+
/**
|
|
3044
|
+
* Order
|
|
3045
|
+
*/
|
|
1432
3046
|
order: number;
|
|
3047
|
+
/**
|
|
3048
|
+
* Created At
|
|
3049
|
+
*/
|
|
1433
3050
|
created_at: string;
|
|
3051
|
+
/**
|
|
3052
|
+
* Updated At
|
|
3053
|
+
*/
|
|
1434
3054
|
updated_at: string;
|
|
1435
3055
|
};
|
|
1436
3056
|
/**
|
|
3057
|
+
* WorkflowPostRunCheckUpsert
|
|
3058
|
+
*
|
|
1437
3059
|
* Create/update payload for workflow-managed post-run checks.
|
|
1438
3060
|
*/
|
|
1439
3061
|
export type WorkflowPostRunCheckUpsert = {
|
|
3062
|
+
/**
|
|
3063
|
+
* Name
|
|
3064
|
+
*/
|
|
1440
3065
|
name: string;
|
|
3066
|
+
/**
|
|
3067
|
+
* Description
|
|
3068
|
+
*/
|
|
1441
3069
|
description?: string | null;
|
|
1442
3070
|
type: PostRunCheckType;
|
|
1443
3071
|
file_target_mode?: PostRunCheckFileTargetMode | null;
|
|
3072
|
+
/**
|
|
3073
|
+
* File Names
|
|
3074
|
+
*/
|
|
1444
3075
|
file_names?: Array<string> | null;
|
|
3076
|
+
/**
|
|
3077
|
+
* File Name Regex
|
|
3078
|
+
*/
|
|
1445
3079
|
file_name_regex?: string | null;
|
|
3080
|
+
/**
|
|
3081
|
+
* Expected Match Count
|
|
3082
|
+
*/
|
|
1446
3083
|
expected_match_count?: number | null;
|
|
3084
|
+
/**
|
|
3085
|
+
* Expected Match Count Ref
|
|
3086
|
+
*/
|
|
1447
3087
|
expected_match_count_ref?: string | null;
|
|
3088
|
+
/**
|
|
3089
|
+
* Loop Input
|
|
3090
|
+
*/
|
|
1448
3091
|
loop_input?: string | null;
|
|
3092
|
+
/**
|
|
3093
|
+
* Loop Item Filename Template
|
|
3094
|
+
*/
|
|
1449
3095
|
loop_item_filename_template?: string | null;
|
|
3096
|
+
/**
|
|
3097
|
+
* Check Prompt
|
|
3098
|
+
*/
|
|
1450
3099
|
check_prompt?: string | null;
|
|
1451
3100
|
/**
|
|
3101
|
+
* Model
|
|
3102
|
+
*
|
|
1452
3103
|
* Optional ModelConfiguration id override for agentic post-run checks.
|
|
1453
3104
|
*/
|
|
1454
3105
|
model?: string | null;
|
|
3106
|
+
/**
|
|
3107
|
+
* Id
|
|
3108
|
+
*/
|
|
1455
3109
|
id?: string | null;
|
|
1456
3110
|
};
|
|
1457
3111
|
/**
|
|
3112
|
+
* WorkflowPromptImageListItem
|
|
3113
|
+
*
|
|
1458
3114
|
* Schema for an item in the workflow prompt images list
|
|
1459
3115
|
*/
|
|
1460
3116
|
export type WorkflowPromptImageListItem = {
|
|
1461
3117
|
/**
|
|
3118
|
+
* Supabase Url
|
|
3119
|
+
*
|
|
1462
3120
|
* The stable supabase:// URL to use in workflow prompt HTML
|
|
1463
3121
|
*/
|
|
1464
3122
|
supabase_url: string;
|
|
1465
3123
|
/**
|
|
3124
|
+
* Path
|
|
3125
|
+
*
|
|
1466
3126
|
* The storage path of the image
|
|
1467
3127
|
*/
|
|
1468
3128
|
path: string;
|
|
1469
3129
|
/**
|
|
3130
|
+
* Filename
|
|
3131
|
+
*
|
|
1470
3132
|
* The filename of the image
|
|
1471
3133
|
*/
|
|
1472
3134
|
filename: string;
|
|
1473
3135
|
/**
|
|
3136
|
+
* Created At
|
|
3137
|
+
*
|
|
1474
3138
|
* When the image was uploaded
|
|
1475
3139
|
*/
|
|
1476
3140
|
created_at?: string | null;
|
|
1477
3141
|
/**
|
|
3142
|
+
* Size Bytes
|
|
3143
|
+
*
|
|
1478
3144
|
* The size of the file in bytes
|
|
1479
3145
|
*/
|
|
1480
3146
|
size_bytes?: number | null;
|
|
1481
3147
|
};
|
|
1482
3148
|
/**
|
|
3149
|
+
* WorkflowPromptImageResponse
|
|
3150
|
+
*
|
|
1483
3151
|
* Response schema for uploaded workflow prompt image
|
|
1484
3152
|
*/
|
|
1485
3153
|
export type WorkflowPromptImageResponse = {
|
|
1486
3154
|
/**
|
|
3155
|
+
* Supabase Url
|
|
3156
|
+
*
|
|
1487
3157
|
* The stable supabase:// URL to use in workflow prompt HTML. Example: supabase://workflow-prompt-images/org_xxx/prompt-assets/image.png
|
|
1488
3158
|
*/
|
|
1489
3159
|
supabase_url: string;
|
|
1490
3160
|
/**
|
|
3161
|
+
* Signed Url
|
|
3162
|
+
*
|
|
1491
3163
|
* A temporary signed URL for immediate display (expires in 1 hour)
|
|
1492
3164
|
*/
|
|
1493
3165
|
signed_url: string;
|
|
1494
3166
|
/**
|
|
3167
|
+
* Filename
|
|
3168
|
+
*
|
|
1495
3169
|
* The sanitized filename as stored
|
|
1496
3170
|
*/
|
|
1497
3171
|
filename: string;
|
|
1498
3172
|
/**
|
|
3173
|
+
* Content Type
|
|
3174
|
+
*
|
|
1499
3175
|
* The MIME type of the uploaded image
|
|
1500
3176
|
*/
|
|
1501
3177
|
content_type: string;
|
|
1502
3178
|
/**
|
|
3179
|
+
* Size Bytes
|
|
3180
|
+
*
|
|
1503
3181
|
* The size of the uploaded file in bytes
|
|
1504
3182
|
*/
|
|
1505
3183
|
size_bytes: number;
|
|
1506
3184
|
};
|
|
1507
3185
|
/**
|
|
3186
|
+
* WorkflowPromptImageSignedUrlResponse
|
|
3187
|
+
*
|
|
1508
3188
|
* Response schema for getting a signed URL for an existing image
|
|
1509
3189
|
*/
|
|
1510
3190
|
export type WorkflowPromptImageSignedUrlResponse = {
|
|
1511
3191
|
/**
|
|
3192
|
+
* Supabase Url
|
|
3193
|
+
*
|
|
1512
3194
|
* The stable supabase:// URL
|
|
1513
3195
|
*/
|
|
1514
3196
|
supabase_url: string;
|
|
1515
3197
|
/**
|
|
3198
|
+
* Signed Url
|
|
3199
|
+
*
|
|
1516
3200
|
* A temporary signed URL (expires in 1 hour)
|
|
1517
3201
|
*/
|
|
1518
3202
|
signed_url: string;
|
|
1519
3203
|
/**
|
|
3204
|
+
* Expires In
|
|
3205
|
+
*
|
|
1520
3206
|
* Seconds until the signed URL expires
|
|
1521
3207
|
*/
|
|
1522
3208
|
expires_in: number;
|
|
1523
3209
|
};
|
|
1524
3210
|
/**
|
|
3211
|
+
* WorkflowResponse
|
|
3212
|
+
*
|
|
1525
3213
|
* Workflow response schema
|
|
1526
3214
|
*/
|
|
1527
3215
|
export type WorkflowResponse = {
|
|
3216
|
+
/**
|
|
3217
|
+
* Name
|
|
3218
|
+
*/
|
|
1528
3219
|
name?: string | null;
|
|
3220
|
+
/**
|
|
3221
|
+
* Main Prompt
|
|
3222
|
+
*/
|
|
1529
3223
|
main_prompt: string;
|
|
1530
3224
|
/**
|
|
3225
|
+
* Input Schema
|
|
3226
|
+
*
|
|
1531
3227
|
* JSON schema for validating merged run inputs. Sensitive root keys are exposed with a '$' prefix in schema validation (for example sensitive_input_values.api_key -> '$api_key').
|
|
1532
3228
|
*/
|
|
1533
3229
|
input_schema?: string | null;
|
|
1534
3230
|
/**
|
|
3231
|
+
* Output Schema
|
|
3232
|
+
*
|
|
1535
3233
|
* JSON schema for output data transformation
|
|
1536
3234
|
*/
|
|
1537
3235
|
output_schema?: string | null;
|
|
1538
3236
|
/**
|
|
3237
|
+
* Includes File Exports
|
|
3238
|
+
*
|
|
1539
3239
|
* Enable AI-based file export detection
|
|
1540
3240
|
*/
|
|
1541
3241
|
includes_file_exports?: boolean;
|
|
1542
3242
|
/**
|
|
3243
|
+
* Is Webhooks Enabled
|
|
3244
|
+
*
|
|
1543
3245
|
* Send webhook on run completion
|
|
1544
3246
|
*/
|
|
1545
3247
|
is_webhooks_enabled?: boolean;
|
|
@@ -1547,47 +3249,88 @@ export type WorkflowResponse = {
|
|
|
1547
3249
|
* Optional workflow-level model configuration metadata (main agent, cache detection, and fallbacks).
|
|
1548
3250
|
*/
|
|
1549
3251
|
model_metadata?: WorkflowModelMetadata | null;
|
|
3252
|
+
/**
|
|
3253
|
+
* Id
|
|
3254
|
+
*/
|
|
1550
3255
|
id: string;
|
|
3256
|
+
/**
|
|
3257
|
+
* User Id
|
|
3258
|
+
*/
|
|
1551
3259
|
user_id?: string | null;
|
|
3260
|
+
/**
|
|
3261
|
+
* Organization Id
|
|
3262
|
+
*/
|
|
1552
3263
|
organization_id?: string | null;
|
|
3264
|
+
/**
|
|
3265
|
+
* Includes Input Variables
|
|
3266
|
+
*/
|
|
1553
3267
|
includes_input_variables?: boolean;
|
|
1554
3268
|
/**
|
|
1555
3269
|
* Internal workflow metadata used for run/error tracking.
|
|
1556
3270
|
*/
|
|
1557
3271
|
workflow_metadata?: WorkflowInternalMetadata | null;
|
|
3272
|
+
/**
|
|
3273
|
+
* Old Versions
|
|
3274
|
+
*/
|
|
1558
3275
|
old_versions?: Array<{
|
|
1559
3276
|
[key: string]: unknown;
|
|
1560
3277
|
}> | null;
|
|
3278
|
+
/**
|
|
3279
|
+
* Created At
|
|
3280
|
+
*/
|
|
1561
3281
|
created_at: string;
|
|
3282
|
+
/**
|
|
3283
|
+
* Updated At
|
|
3284
|
+
*/
|
|
1562
3285
|
updated_at: string;
|
|
1563
3286
|
/**
|
|
3287
|
+
* Tags
|
|
3288
|
+
*
|
|
1564
3289
|
* Tags assigned to this workflow
|
|
1565
3290
|
*/
|
|
1566
3291
|
tags?: Array<WorkflowTagResponse> | null;
|
|
1567
3292
|
/**
|
|
3293
|
+
* Post Run Checks
|
|
3294
|
+
*
|
|
1568
3295
|
* Post-run checks assigned to this workflow.
|
|
1569
3296
|
*/
|
|
1570
3297
|
post_run_checks?: Array<WorkflowPostRunCheckResponse> | null;
|
|
1571
3298
|
};
|
|
1572
3299
|
/**
|
|
3300
|
+
* WorkflowResponseWithIncludes
|
|
3301
|
+
*
|
|
1573
3302
|
* Workflow response with optional included related resources.
|
|
1574
3303
|
*/
|
|
1575
3304
|
export type WorkflowResponseWithIncludes = {
|
|
3305
|
+
/**
|
|
3306
|
+
* Name
|
|
3307
|
+
*/
|
|
1576
3308
|
name?: string | null;
|
|
3309
|
+
/**
|
|
3310
|
+
* Main Prompt
|
|
3311
|
+
*/
|
|
1577
3312
|
main_prompt: string;
|
|
1578
3313
|
/**
|
|
3314
|
+
* Input Schema
|
|
3315
|
+
*
|
|
1579
3316
|
* JSON schema for validating merged run inputs. Sensitive root keys are exposed with a '$' prefix in schema validation (for example sensitive_input_values.api_key -> '$api_key').
|
|
1580
3317
|
*/
|
|
1581
3318
|
input_schema?: string | null;
|
|
1582
3319
|
/**
|
|
3320
|
+
* Output Schema
|
|
3321
|
+
*
|
|
1583
3322
|
* JSON schema for output data transformation
|
|
1584
3323
|
*/
|
|
1585
3324
|
output_schema?: string | null;
|
|
1586
3325
|
/**
|
|
3326
|
+
* Includes File Exports
|
|
3327
|
+
*
|
|
1587
3328
|
* Enable AI-based file export detection
|
|
1588
3329
|
*/
|
|
1589
3330
|
includes_file_exports?: boolean;
|
|
1590
3331
|
/**
|
|
3332
|
+
* Is Webhooks Enabled
|
|
3333
|
+
*
|
|
1591
3334
|
* Send webhook on run completion
|
|
1592
3335
|
*/
|
|
1593
3336
|
is_webhooks_enabled?: boolean;
|
|
@@ -1595,96 +3338,232 @@ export type WorkflowResponseWithIncludes = {
|
|
|
1595
3338
|
* Optional workflow-level model configuration metadata (main agent, cache detection, and fallbacks).
|
|
1596
3339
|
*/
|
|
1597
3340
|
model_metadata?: WorkflowModelMetadata | null;
|
|
3341
|
+
/**
|
|
3342
|
+
* Id
|
|
3343
|
+
*/
|
|
1598
3344
|
id: string;
|
|
3345
|
+
/**
|
|
3346
|
+
* User Id
|
|
3347
|
+
*/
|
|
1599
3348
|
user_id?: string | null;
|
|
3349
|
+
/**
|
|
3350
|
+
* Organization Id
|
|
3351
|
+
*/
|
|
1600
3352
|
organization_id?: string | null;
|
|
3353
|
+
/**
|
|
3354
|
+
* Includes Input Variables
|
|
3355
|
+
*/
|
|
1601
3356
|
includes_input_variables?: boolean;
|
|
1602
3357
|
/**
|
|
1603
3358
|
* Internal workflow metadata used for run/error tracking.
|
|
1604
3359
|
*/
|
|
1605
3360
|
workflow_metadata?: WorkflowInternalMetadata | null;
|
|
3361
|
+
/**
|
|
3362
|
+
* Old Versions
|
|
3363
|
+
*/
|
|
1606
3364
|
old_versions?: Array<{
|
|
1607
3365
|
[key: string]: unknown;
|
|
1608
3366
|
}> | null;
|
|
3367
|
+
/**
|
|
3368
|
+
* Created At
|
|
3369
|
+
*/
|
|
1609
3370
|
created_at: string;
|
|
3371
|
+
/**
|
|
3372
|
+
* Updated At
|
|
3373
|
+
*/
|
|
1610
3374
|
updated_at: string;
|
|
1611
3375
|
/**
|
|
3376
|
+
* Tags
|
|
3377
|
+
*
|
|
1612
3378
|
* Tags assigned to this workflow
|
|
1613
3379
|
*/
|
|
1614
3380
|
tags?: Array<WorkflowTagResponse> | null;
|
|
1615
3381
|
/**
|
|
3382
|
+
* Post Run Checks
|
|
3383
|
+
*
|
|
1616
3384
|
* Post-run checks assigned to this workflow.
|
|
1617
3385
|
*/
|
|
1618
3386
|
post_run_checks?: Array<WorkflowPostRunCheckResponse> | null;
|
|
1619
3387
|
/**
|
|
3388
|
+
* Included
|
|
3389
|
+
*
|
|
1620
3390
|
* Related resources requested via the `include` query parameter
|
|
1621
3391
|
*/
|
|
1622
3392
|
included?: Array<IncludedResource> | null;
|
|
1623
3393
|
};
|
|
1624
3394
|
/**
|
|
3395
|
+
* WorkflowTagCreate
|
|
3396
|
+
*
|
|
1625
3397
|
* Schema for creating a workflow tag
|
|
1626
3398
|
*/
|
|
1627
3399
|
export type WorkflowTagCreate = {
|
|
3400
|
+
/**
|
|
3401
|
+
* Name
|
|
3402
|
+
*/
|
|
1628
3403
|
name: string;
|
|
3404
|
+
/**
|
|
3405
|
+
* Description
|
|
3406
|
+
*/
|
|
1629
3407
|
description?: string | null;
|
|
3408
|
+
/**
|
|
3409
|
+
* Emoji
|
|
3410
|
+
*/
|
|
1630
3411
|
emoji?: string | null;
|
|
3412
|
+
/**
|
|
3413
|
+
* Color
|
|
3414
|
+
*/
|
|
1631
3415
|
color?: string | null;
|
|
1632
3416
|
/**
|
|
3417
|
+
* Group Id
|
|
3418
|
+
*
|
|
1633
3419
|
* Optional group for mutual exclusivity
|
|
1634
3420
|
*/
|
|
1635
3421
|
group_id?: string | null;
|
|
1636
3422
|
};
|
|
1637
3423
|
/**
|
|
3424
|
+
* WorkflowTagGroupCreate
|
|
3425
|
+
*
|
|
1638
3426
|
* Schema for creating a workflow tag group
|
|
1639
3427
|
*/
|
|
1640
3428
|
export type WorkflowTagGroupCreate = {
|
|
3429
|
+
/**
|
|
3430
|
+
* Name
|
|
3431
|
+
*/
|
|
1641
3432
|
name: string;
|
|
3433
|
+
/**
|
|
3434
|
+
* Description
|
|
3435
|
+
*/
|
|
1642
3436
|
description?: string | null;
|
|
3437
|
+
/**
|
|
3438
|
+
* Emoji
|
|
3439
|
+
*/
|
|
1643
3440
|
emoji?: string | null;
|
|
3441
|
+
/**
|
|
3442
|
+
* Color
|
|
3443
|
+
*/
|
|
1644
3444
|
color?: string | null;
|
|
1645
3445
|
};
|
|
1646
3446
|
/**
|
|
3447
|
+
* WorkflowTagGroupResponse
|
|
3448
|
+
*
|
|
1647
3449
|
* Workflow tag group response schema
|
|
1648
3450
|
*/
|
|
1649
3451
|
export type WorkflowTagGroupResponse = {
|
|
3452
|
+
/**
|
|
3453
|
+
* Name
|
|
3454
|
+
*/
|
|
1650
3455
|
name: string;
|
|
3456
|
+
/**
|
|
3457
|
+
* Description
|
|
3458
|
+
*/
|
|
1651
3459
|
description?: string | null;
|
|
3460
|
+
/**
|
|
3461
|
+
* Emoji
|
|
3462
|
+
*/
|
|
1652
3463
|
emoji?: string | null;
|
|
3464
|
+
/**
|
|
3465
|
+
* Color
|
|
3466
|
+
*/
|
|
1653
3467
|
color?: string | null;
|
|
3468
|
+
/**
|
|
3469
|
+
* Id
|
|
3470
|
+
*/
|
|
1654
3471
|
id: string;
|
|
3472
|
+
/**
|
|
3473
|
+
* Organization Id
|
|
3474
|
+
*/
|
|
1655
3475
|
organization_id: string;
|
|
3476
|
+
/**
|
|
3477
|
+
* Order
|
|
3478
|
+
*/
|
|
1656
3479
|
order: number;
|
|
3480
|
+
/**
|
|
3481
|
+
* Created At
|
|
3482
|
+
*/
|
|
1657
3483
|
created_at: string;
|
|
3484
|
+
/**
|
|
3485
|
+
* Updated At
|
|
3486
|
+
*/
|
|
1658
3487
|
updated_at: string;
|
|
1659
3488
|
};
|
|
1660
3489
|
/**
|
|
3490
|
+
* WorkflowTagGroupUpdate
|
|
3491
|
+
*
|
|
1661
3492
|
* Schema for updating a workflow tag group
|
|
1662
3493
|
*/
|
|
1663
3494
|
export type WorkflowTagGroupUpdate = {
|
|
3495
|
+
/**
|
|
3496
|
+
* Name
|
|
3497
|
+
*/
|
|
1664
3498
|
name?: string | null;
|
|
3499
|
+
/**
|
|
3500
|
+
* Description
|
|
3501
|
+
*/
|
|
1665
3502
|
description?: string | null;
|
|
3503
|
+
/**
|
|
3504
|
+
* Emoji
|
|
3505
|
+
*/
|
|
1666
3506
|
emoji?: string | null;
|
|
3507
|
+
/**
|
|
3508
|
+
* Color
|
|
3509
|
+
*/
|
|
1667
3510
|
color?: string | null;
|
|
1668
3511
|
};
|
|
1669
3512
|
/**
|
|
3513
|
+
* WorkflowTagResponse
|
|
3514
|
+
*
|
|
1670
3515
|
* Workflow tag response schema
|
|
1671
3516
|
*/
|
|
1672
3517
|
export type WorkflowTagResponse = {
|
|
3518
|
+
/**
|
|
3519
|
+
* Name
|
|
3520
|
+
*/
|
|
1673
3521
|
name: string;
|
|
3522
|
+
/**
|
|
3523
|
+
* Description
|
|
3524
|
+
*/
|
|
1674
3525
|
description?: string | null;
|
|
3526
|
+
/**
|
|
3527
|
+
* Emoji
|
|
3528
|
+
*/
|
|
1675
3529
|
emoji?: string | null;
|
|
3530
|
+
/**
|
|
3531
|
+
* Color
|
|
3532
|
+
*/
|
|
1676
3533
|
color?: string | null;
|
|
1677
3534
|
/**
|
|
3535
|
+
* Group Id
|
|
3536
|
+
*
|
|
1678
3537
|
* Optional group for mutual exclusivity
|
|
1679
3538
|
*/
|
|
1680
3539
|
group_id?: string | null;
|
|
3540
|
+
/**
|
|
3541
|
+
* Id
|
|
3542
|
+
*/
|
|
1681
3543
|
id: string;
|
|
3544
|
+
/**
|
|
3545
|
+
* Organization Id
|
|
3546
|
+
*/
|
|
1682
3547
|
organization_id: string;
|
|
3548
|
+
/**
|
|
3549
|
+
* Order
|
|
3550
|
+
*/
|
|
1683
3551
|
order: number;
|
|
3552
|
+
/**
|
|
3553
|
+
* Is Archived
|
|
3554
|
+
*/
|
|
1684
3555
|
is_archived?: boolean;
|
|
3556
|
+
/**
|
|
3557
|
+
* Created At
|
|
3558
|
+
*/
|
|
1685
3559
|
created_at: string;
|
|
3560
|
+
/**
|
|
3561
|
+
* Updated At
|
|
3562
|
+
*/
|
|
1686
3563
|
updated_at: string;
|
|
1687
3564
|
/**
|
|
3565
|
+
* Workflow Count
|
|
3566
|
+
*
|
|
1688
3567
|
* Number of workflows with this tag (returned in list endpoint)
|
|
1689
3568
|
*/
|
|
1690
3569
|
workflow_count?: number | null;
|
|
@@ -1694,41 +3573,75 @@ export type WorkflowTagResponse = {
|
|
|
1694
3573
|
group?: WorkflowTagGroupResponse | null;
|
|
1695
3574
|
};
|
|
1696
3575
|
/**
|
|
3576
|
+
* WorkflowTagUpdate
|
|
3577
|
+
*
|
|
1697
3578
|
* Schema for updating a workflow tag
|
|
1698
3579
|
*/
|
|
1699
3580
|
export type WorkflowTagUpdate = {
|
|
3581
|
+
/**
|
|
3582
|
+
* Name
|
|
3583
|
+
*/
|
|
1700
3584
|
name?: string | null;
|
|
3585
|
+
/**
|
|
3586
|
+
* Description
|
|
3587
|
+
*/
|
|
1701
3588
|
description?: string | null;
|
|
3589
|
+
/**
|
|
3590
|
+
* Emoji
|
|
3591
|
+
*/
|
|
1702
3592
|
emoji?: string | null;
|
|
3593
|
+
/**
|
|
3594
|
+
* Color
|
|
3595
|
+
*/
|
|
1703
3596
|
color?: string | null;
|
|
1704
3597
|
/**
|
|
3598
|
+
* Group Id
|
|
3599
|
+
*
|
|
1705
3600
|
* Optional group for mutual exclusivity
|
|
1706
3601
|
*/
|
|
1707
3602
|
group_id?: string | null;
|
|
1708
3603
|
/**
|
|
3604
|
+
* Is Archived
|
|
3605
|
+
*
|
|
1709
3606
|
* Archive tag to prevent new assignments
|
|
1710
3607
|
*/
|
|
1711
3608
|
is_archived?: boolean | null;
|
|
1712
3609
|
};
|
|
1713
3610
|
/**
|
|
3611
|
+
* WorkflowUpdate
|
|
3612
|
+
*
|
|
1714
3613
|
* Schema for updating a workflow
|
|
1715
3614
|
*/
|
|
1716
3615
|
export type WorkflowUpdate = {
|
|
3616
|
+
/**
|
|
3617
|
+
* Name
|
|
3618
|
+
*/
|
|
1717
3619
|
name?: string | null;
|
|
3620
|
+
/**
|
|
3621
|
+
* Main Prompt
|
|
3622
|
+
*/
|
|
1718
3623
|
main_prompt?: string | null;
|
|
1719
3624
|
/**
|
|
3625
|
+
* Input Schema
|
|
3626
|
+
*
|
|
1720
3627
|
* JSON schema for validating merged run inputs. Sensitive root keys are exposed with a '$' prefix in schema validation (for example sensitive_input_values.api_key -> '$api_key').
|
|
1721
3628
|
*/
|
|
1722
3629
|
input_schema?: string | null;
|
|
1723
3630
|
/**
|
|
3631
|
+
* Output Schema
|
|
3632
|
+
*
|
|
1724
3633
|
* JSON schema for output data transformation
|
|
1725
3634
|
*/
|
|
1726
3635
|
output_schema?: string | null;
|
|
1727
3636
|
/**
|
|
3637
|
+
* Includes File Exports
|
|
3638
|
+
*
|
|
1728
3639
|
* Enable AI-based file export detection
|
|
1729
3640
|
*/
|
|
1730
3641
|
includes_file_exports?: boolean | null;
|
|
1731
3642
|
/**
|
|
3643
|
+
* Is Webhooks Enabled
|
|
3644
|
+
*
|
|
1732
3645
|
* Send webhook on run completion
|
|
1733
3646
|
*/
|
|
1734
3647
|
is_webhooks_enabled?: boolean | null;
|
|
@@ -1741,6 +3654,8 @@ export type WorkflowUpdate = {
|
|
|
1741
3654
|
*/
|
|
1742
3655
|
workflow_metadata?: WorkflowInternalMetadataUpdate | null;
|
|
1743
3656
|
/**
|
|
3657
|
+
* Post Run Checks
|
|
3658
|
+
*
|
|
1744
3659
|
* Workflow-managed post-run checks, reconciled on save when present.
|
|
1745
3660
|
*/
|
|
1746
3661
|
post_run_checks?: Array<WorkflowPostRunCheckUpsert> | null;
|
|
@@ -1753,6 +3668,8 @@ export type HealthCheckV1HealthGetData = {
|
|
|
1753
3668
|
};
|
|
1754
3669
|
export type HealthCheckV1HealthGetResponses = {
|
|
1755
3670
|
/**
|
|
3671
|
+
* Response Health Check V1 Health Get
|
|
3672
|
+
*
|
|
1756
3673
|
* Successful Response
|
|
1757
3674
|
*/
|
|
1758
3675
|
200: {
|
|
@@ -1777,26 +3694,42 @@ export type ListMachinesV1MachinesGetData = {
|
|
|
1777
3694
|
path?: never;
|
|
1778
3695
|
query?: {
|
|
1779
3696
|
/**
|
|
3697
|
+
* Search
|
|
3698
|
+
*
|
|
1780
3699
|
* Search machines by id, name, or hostname (case-insensitive substring match)
|
|
1781
3700
|
*/
|
|
1782
3701
|
search?: string | null;
|
|
1783
3702
|
/**
|
|
3703
|
+
* Status
|
|
3704
|
+
*
|
|
1784
3705
|
* Filter by machine status
|
|
1785
3706
|
*/
|
|
1786
3707
|
status?: MachineStatus | null;
|
|
1787
3708
|
/**
|
|
3709
|
+
* Created At From
|
|
3710
|
+
*
|
|
1788
3711
|
* Filter machines created at or after this ISO timestamp (UTC)
|
|
1789
3712
|
*/
|
|
1790
3713
|
created_at_from?: string | null;
|
|
1791
3714
|
/**
|
|
3715
|
+
* Created At To
|
|
3716
|
+
*
|
|
1792
3717
|
* Filter machines created at or before this ISO timestamp (UTC)
|
|
1793
3718
|
*/
|
|
1794
3719
|
created_at_to?: string | null;
|
|
1795
3720
|
/**
|
|
3721
|
+
* Include
|
|
3722
|
+
*
|
|
1796
3723
|
* Comma-separated list of related resources to include. Allowed values: pools. Example: include=pools
|
|
1797
3724
|
*/
|
|
1798
3725
|
include?: string | null;
|
|
3726
|
+
/**
|
|
3727
|
+
* Skip
|
|
3728
|
+
*/
|
|
1799
3729
|
skip?: number;
|
|
3730
|
+
/**
|
|
3731
|
+
* Limit
|
|
3732
|
+
*/
|
|
1800
3733
|
limit?: number;
|
|
1801
3734
|
};
|
|
1802
3735
|
url: '/v1/machines';
|
|
@@ -1850,6 +3783,9 @@ export type DeleteMachineV1MachinesMachineIdDeleteData = {
|
|
|
1850
3783
|
'Idempotency-Key'?: string;
|
|
1851
3784
|
};
|
|
1852
3785
|
path: {
|
|
3786
|
+
/**
|
|
3787
|
+
* Machine Id
|
|
3788
|
+
*/
|
|
1853
3789
|
machine_id: string;
|
|
1854
3790
|
};
|
|
1855
3791
|
query?: never;
|
|
@@ -1872,10 +3808,15 @@ export type DeleteMachineV1MachinesMachineIdDeleteResponse = DeleteMachineV1Mach
|
|
|
1872
3808
|
export type GetMachineV1MachinesMachineIdGetData = {
|
|
1873
3809
|
body?: never;
|
|
1874
3810
|
path: {
|
|
3811
|
+
/**
|
|
3812
|
+
* Machine Id
|
|
3813
|
+
*/
|
|
1875
3814
|
machine_id: string;
|
|
1876
3815
|
};
|
|
1877
3816
|
query?: {
|
|
1878
3817
|
/**
|
|
3818
|
+
* Include
|
|
3819
|
+
*
|
|
1879
3820
|
* Comma-separated list of related resources to include. Allowed values: pools. Example: include=pools
|
|
1880
3821
|
*/
|
|
1881
3822
|
include?: string | null;
|
|
@@ -1905,6 +3846,9 @@ export type UpdateMachineV1MachinesMachineIdPatchData = {
|
|
|
1905
3846
|
'Idempotency-Key'?: string;
|
|
1906
3847
|
};
|
|
1907
3848
|
path: {
|
|
3849
|
+
/**
|
|
3850
|
+
* Machine Id
|
|
3851
|
+
*/
|
|
1908
3852
|
machine_id: string;
|
|
1909
3853
|
};
|
|
1910
3854
|
query?: never;
|
|
@@ -1927,6 +3871,9 @@ export type UpdateMachineV1MachinesMachineIdPatchResponse = UpdateMachineV1Machi
|
|
|
1927
3871
|
export type GetMachinePoolsV1MachinesMachineIdPoolsGetData = {
|
|
1928
3872
|
body?: never;
|
|
1929
3873
|
path: {
|
|
3874
|
+
/**
|
|
3875
|
+
* Machine Id
|
|
3876
|
+
*/
|
|
1930
3877
|
machine_id: string;
|
|
1931
3878
|
};
|
|
1932
3879
|
query?: never;
|
|
@@ -1941,6 +3888,8 @@ export type GetMachinePoolsV1MachinesMachineIdPoolsGetErrors = {
|
|
|
1941
3888
|
export type GetMachinePoolsV1MachinesMachineIdPoolsGetError = GetMachinePoolsV1MachinesMachineIdPoolsGetErrors[keyof GetMachinePoolsV1MachinesMachineIdPoolsGetErrors];
|
|
1942
3889
|
export type GetMachinePoolsV1MachinesMachineIdPoolsGetResponses = {
|
|
1943
3890
|
/**
|
|
3891
|
+
* Response Get Machine Pools V1 Machines Machine Id Pools Get
|
|
3892
|
+
*
|
|
1944
3893
|
* Successful Response
|
|
1945
3894
|
*/
|
|
1946
3895
|
200: Array<PoolResponse>;
|
|
@@ -1955,6 +3904,9 @@ export type UpdateMachinePoolsV1MachinesMachineIdPoolsPutData = {
|
|
|
1955
3904
|
'Idempotency-Key'?: string;
|
|
1956
3905
|
};
|
|
1957
3906
|
path: {
|
|
3907
|
+
/**
|
|
3908
|
+
* Machine Id
|
|
3909
|
+
*/
|
|
1958
3910
|
machine_id: string;
|
|
1959
3911
|
};
|
|
1960
3912
|
query?: never;
|
|
@@ -1979,10 +3931,18 @@ export type ListPoolsV1PoolsGetData = {
|
|
|
1979
3931
|
path?: never;
|
|
1980
3932
|
query?: {
|
|
1981
3933
|
/**
|
|
3934
|
+
* Include
|
|
3935
|
+
*
|
|
1982
3936
|
* Comma-separated list of related resources to include. Allowed values: machines. Example: include=machines
|
|
1983
3937
|
*/
|
|
1984
3938
|
include?: string | null;
|
|
3939
|
+
/**
|
|
3940
|
+
* Skip
|
|
3941
|
+
*/
|
|
1985
3942
|
skip?: number;
|
|
3943
|
+
/**
|
|
3944
|
+
* Limit
|
|
3945
|
+
*/
|
|
1986
3946
|
limit?: number;
|
|
1987
3947
|
};
|
|
1988
3948
|
url: '/v1/pools';
|
|
@@ -2036,6 +3996,9 @@ export type DeletePoolV1PoolsPoolIdDeleteData = {
|
|
|
2036
3996
|
'Idempotency-Key'?: string;
|
|
2037
3997
|
};
|
|
2038
3998
|
path: {
|
|
3999
|
+
/**
|
|
4000
|
+
* Pool Id
|
|
4001
|
+
*/
|
|
2039
4002
|
pool_id: string;
|
|
2040
4003
|
};
|
|
2041
4004
|
query?: never;
|
|
@@ -2058,14 +4021,21 @@ export type DeletePoolV1PoolsPoolIdDeleteResponse = DeletePoolV1PoolsPoolIdDelet
|
|
|
2058
4021
|
export type GetPoolV1PoolsPoolIdGetData = {
|
|
2059
4022
|
body?: never;
|
|
2060
4023
|
path: {
|
|
4024
|
+
/**
|
|
4025
|
+
* Pool Id
|
|
4026
|
+
*/
|
|
2061
4027
|
pool_id: string;
|
|
2062
4028
|
};
|
|
2063
4029
|
query?: {
|
|
2064
4030
|
/**
|
|
4031
|
+
* Include Machines
|
|
4032
|
+
*
|
|
2065
4033
|
* [Deprecated] Use include=machines instead. Include full machine details
|
|
2066
4034
|
*/
|
|
2067
4035
|
include_machines?: boolean;
|
|
2068
4036
|
/**
|
|
4037
|
+
* Include
|
|
4038
|
+
*
|
|
2069
4039
|
* Comma-separated list of related resources to include. Allowed values: machines. Example: include=machines
|
|
2070
4040
|
*/
|
|
2071
4041
|
include?: string | null;
|
|
@@ -2095,6 +4065,9 @@ export type UpdatePoolV1PoolsPoolIdPatchData = {
|
|
|
2095
4065
|
'Idempotency-Key'?: string;
|
|
2096
4066
|
};
|
|
2097
4067
|
path: {
|
|
4068
|
+
/**
|
|
4069
|
+
* Pool Id
|
|
4070
|
+
*/
|
|
2098
4071
|
pool_id: string;
|
|
2099
4072
|
};
|
|
2100
4073
|
query?: never;
|
|
@@ -2123,6 +4096,9 @@ export type RemoveMachinesFromPoolV1PoolsPoolIdMachinesDeleteData = {
|
|
|
2123
4096
|
'Idempotency-Key'?: string;
|
|
2124
4097
|
};
|
|
2125
4098
|
path: {
|
|
4099
|
+
/**
|
|
4100
|
+
* Pool Id
|
|
4101
|
+
*/
|
|
2126
4102
|
pool_id: string;
|
|
2127
4103
|
};
|
|
2128
4104
|
query?: never;
|
|
@@ -2151,6 +4127,9 @@ export type AddMachinesToPoolV1PoolsPoolIdMachinesPostData = {
|
|
|
2151
4127
|
'Idempotency-Key'?: string;
|
|
2152
4128
|
};
|
|
2153
4129
|
path: {
|
|
4130
|
+
/**
|
|
4131
|
+
* Pool Id
|
|
4132
|
+
*/
|
|
2154
4133
|
pool_id: string;
|
|
2155
4134
|
};
|
|
2156
4135
|
query?: never;
|
|
@@ -2175,38 +4154,60 @@ export type ListWorkflowsV1WorkflowsGetData = {
|
|
|
2175
4154
|
path?: never;
|
|
2176
4155
|
query?: {
|
|
2177
4156
|
/**
|
|
4157
|
+
* Search
|
|
4158
|
+
*
|
|
2178
4159
|
* Search workflows by id or name (case-insensitive substring match)
|
|
2179
4160
|
*/
|
|
2180
4161
|
search?: string | null;
|
|
2181
4162
|
/**
|
|
4163
|
+
* Created At From
|
|
4164
|
+
*
|
|
2182
4165
|
* Filter workflows created at or after this ISO timestamp (UTC)
|
|
2183
4166
|
*/
|
|
2184
4167
|
created_at_from?: string | null;
|
|
2185
4168
|
/**
|
|
4169
|
+
* Created At To
|
|
4170
|
+
*
|
|
2186
4171
|
* Filter workflows created at or before this ISO timestamp (UTC)
|
|
2187
4172
|
*/
|
|
2188
4173
|
created_at_to?: string | null;
|
|
2189
4174
|
/**
|
|
4175
|
+
* Updated At From
|
|
4176
|
+
*
|
|
2190
4177
|
* Filter workflows updated at or after this ISO timestamp (UTC)
|
|
2191
4178
|
*/
|
|
2192
4179
|
updated_at_from?: string | null;
|
|
2193
4180
|
/**
|
|
4181
|
+
* Updated At To
|
|
4182
|
+
*
|
|
2194
4183
|
* Filter workflows updated at or before this ISO timestamp (UTC)
|
|
2195
4184
|
*/
|
|
2196
4185
|
updated_at_to?: string | null;
|
|
2197
4186
|
/**
|
|
4187
|
+
* Tag Ids
|
|
4188
|
+
*
|
|
2198
4189
|
* Comma-separated list of tag UUIDs. Returns workflows with ALL specified tags (AND logic).
|
|
2199
4190
|
*/
|
|
2200
4191
|
tag_ids?: string | null;
|
|
2201
4192
|
/**
|
|
4193
|
+
* Include Tags
|
|
4194
|
+
*
|
|
2202
4195
|
* Include tags in the response
|
|
2203
4196
|
*/
|
|
2204
4197
|
include_tags?: boolean;
|
|
2205
4198
|
/**
|
|
4199
|
+
* Include
|
|
4200
|
+
*
|
|
2206
4201
|
* Comma-separated list of related resources to include. Allowed values: tags, post_run_checks. If provided, overrides legacy include_tags.
|
|
2207
4202
|
*/
|
|
2208
4203
|
include?: string | null;
|
|
4204
|
+
/**
|
|
4205
|
+
* Skip
|
|
4206
|
+
*/
|
|
2209
4207
|
skip?: number;
|
|
4208
|
+
/**
|
|
4209
|
+
* Limit
|
|
4210
|
+
*/
|
|
2210
4211
|
limit?: number;
|
|
2211
4212
|
};
|
|
2212
4213
|
url: '/v1/workflows';
|
|
@@ -2286,6 +4287,9 @@ export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteData = {
|
|
|
2286
4287
|
'Idempotency-Key'?: string;
|
|
2287
4288
|
};
|
|
2288
4289
|
path: {
|
|
4290
|
+
/**
|
|
4291
|
+
* Workflow Id
|
|
4292
|
+
*/
|
|
2289
4293
|
workflow_id: string;
|
|
2290
4294
|
};
|
|
2291
4295
|
query?: never;
|
|
@@ -2308,10 +4312,15 @@ export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteResponse = DeleteWorkflowV1
|
|
|
2308
4312
|
export type GetWorkflowV1WorkflowsWorkflowIdGetData = {
|
|
2309
4313
|
body?: never;
|
|
2310
4314
|
path: {
|
|
4315
|
+
/**
|
|
4316
|
+
* Workflow Id
|
|
4317
|
+
*/
|
|
2311
4318
|
workflow_id: string;
|
|
2312
4319
|
};
|
|
2313
4320
|
query?: {
|
|
2314
4321
|
/**
|
|
4322
|
+
* Include
|
|
4323
|
+
*
|
|
2315
4324
|
* Comma-separated list of related resources to include. Allowed values: tags, post_run_checks. Defaults to tags and post_run_checks when omitted.
|
|
2316
4325
|
*/
|
|
2317
4326
|
include?: string | null;
|
|
@@ -2341,6 +4350,9 @@ export type UpdateWorkflowV1WorkflowsWorkflowIdPatchData = {
|
|
|
2341
4350
|
'Idempotency-Key'?: string;
|
|
2342
4351
|
};
|
|
2343
4352
|
path: {
|
|
4353
|
+
/**
|
|
4354
|
+
* Workflow Id
|
|
4355
|
+
*/
|
|
2344
4356
|
workflow_id: string;
|
|
2345
4357
|
};
|
|
2346
4358
|
query?: never;
|
|
@@ -2361,6 +4373,9 @@ export type UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses = {
|
|
|
2361
4373
|
};
|
|
2362
4374
|
export type UpdateWorkflowV1WorkflowsWorkflowIdPatchResponse = UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses[keyof UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses];
|
|
2363
4375
|
export type DuplicateWorkflowV1WorkflowsWorkflowIdDuplicatePostData = {
|
|
4376
|
+
/**
|
|
4377
|
+
* Duplicate Data
|
|
4378
|
+
*/
|
|
2364
4379
|
body?: WorkflowDuplicateRequest | null;
|
|
2365
4380
|
headers?: {
|
|
2366
4381
|
/**
|
|
@@ -2369,6 +4384,9 @@ export type DuplicateWorkflowV1WorkflowsWorkflowIdDuplicatePostData = {
|
|
|
2369
4384
|
'Idempotency-Key'?: string;
|
|
2370
4385
|
};
|
|
2371
4386
|
path: {
|
|
4387
|
+
/**
|
|
4388
|
+
* Workflow Id
|
|
4389
|
+
*/
|
|
2372
4390
|
workflow_id: string;
|
|
2373
4391
|
};
|
|
2374
4392
|
query?: never;
|
|
@@ -2397,6 +4415,9 @@ export type MergeWorkflowV1WorkflowsWorkflowIdMergePostData = {
|
|
|
2397
4415
|
'Idempotency-Key'?: string;
|
|
2398
4416
|
};
|
|
2399
4417
|
path: {
|
|
4418
|
+
/**
|
|
4419
|
+
* Workflow Id
|
|
4420
|
+
*/
|
|
2400
4421
|
workflow_id: string;
|
|
2401
4422
|
};
|
|
2402
4423
|
query?: never;
|
|
@@ -2419,6 +4440,9 @@ export type MergeWorkflowV1WorkflowsWorkflowIdMergePostResponse = MergeWorkflowV
|
|
|
2419
4440
|
export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetData = {
|
|
2420
4441
|
body?: never;
|
|
2421
4442
|
path: {
|
|
4443
|
+
/**
|
|
4444
|
+
* Workflow Id
|
|
4445
|
+
*/
|
|
2422
4446
|
workflow_id: string;
|
|
2423
4447
|
};
|
|
2424
4448
|
query?: never;
|
|
@@ -2433,6 +4457,8 @@ export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors = {
|
|
|
2433
4457
|
export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetError = GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors[keyof GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors];
|
|
2434
4458
|
export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetResponses = {
|
|
2435
4459
|
/**
|
|
4460
|
+
* Response Get Workflow Versions V1 Workflows Workflow Id Versions Get
|
|
4461
|
+
*
|
|
2436
4462
|
* Successful Response
|
|
2437
4463
|
*/
|
|
2438
4464
|
200: Array<{
|
|
@@ -2451,6 +4477,8 @@ export type DeleteWorkflowPromptImageV1WorkflowsPromptImageDeleteData = {
|
|
|
2451
4477
|
path?: never;
|
|
2452
4478
|
query: {
|
|
2453
4479
|
/**
|
|
4480
|
+
* Path
|
|
4481
|
+
*
|
|
2454
4482
|
* The storage path of the image to delete
|
|
2455
4483
|
*/
|
|
2456
4484
|
path: string;
|
|
@@ -2505,6 +4533,8 @@ export type ListWorkflowPromptImagesV1WorkflowsPromptImagesGetData = {
|
|
|
2505
4533
|
};
|
|
2506
4534
|
export type ListWorkflowPromptImagesV1WorkflowsPromptImagesGetResponses = {
|
|
2507
4535
|
/**
|
|
4536
|
+
* Response List Workflow Prompt Images V1 Workflows Prompt Images Get
|
|
4537
|
+
*
|
|
2508
4538
|
* Successful Response
|
|
2509
4539
|
*/
|
|
2510
4540
|
200: Array<WorkflowPromptImageListItem>;
|
|
@@ -2515,6 +4545,8 @@ export type GetWorkflowPromptImageSignedUrlV1WorkflowsPromptImageSignedUrlGetDat
|
|
|
2515
4545
|
path?: never;
|
|
2516
4546
|
query: {
|
|
2517
4547
|
/**
|
|
4548
|
+
* Path
|
|
4549
|
+
*
|
|
2518
4550
|
* The storage path of the image (e.g., org_xxx/prompt-assets/image.png)
|
|
2519
4551
|
*/
|
|
2520
4552
|
path: string;
|
|
@@ -2538,6 +4570,9 @@ export type GetWorkflowPromptImageSignedUrlV1WorkflowsPromptImageSignedUrlGetRes
|
|
|
2538
4570
|
export type GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetData = {
|
|
2539
4571
|
body?: never;
|
|
2540
4572
|
path: {
|
|
4573
|
+
/**
|
|
4574
|
+
* Workflow Id
|
|
4575
|
+
*/
|
|
2541
4576
|
workflow_id: string;
|
|
2542
4577
|
};
|
|
2543
4578
|
query?: never;
|
|
@@ -2552,6 +4587,8 @@ export type GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetErrors = {
|
|
|
2552
4587
|
export type GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetError = GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetErrors[keyof GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetErrors];
|
|
2553
4588
|
export type GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetResponses = {
|
|
2554
4589
|
/**
|
|
4590
|
+
* Response Get Workflow Tags V1 Workflows Workflow Id Tags Get
|
|
4591
|
+
*
|
|
2555
4592
|
* Successful Response
|
|
2556
4593
|
*/
|
|
2557
4594
|
200: Array<WorkflowTagResponse>;
|
|
@@ -2566,6 +4603,9 @@ export type AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostData = {
|
|
|
2566
4603
|
'Idempotency-Key'?: string;
|
|
2567
4604
|
};
|
|
2568
4605
|
path: {
|
|
4606
|
+
/**
|
|
4607
|
+
* Workflow Id
|
|
4608
|
+
*/
|
|
2569
4609
|
workflow_id: string;
|
|
2570
4610
|
};
|
|
2571
4611
|
query?: never;
|
|
@@ -2580,6 +4620,8 @@ export type AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostErrors = {
|
|
|
2580
4620
|
export type AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostError = AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostErrors[keyof AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostErrors];
|
|
2581
4621
|
export type AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostResponses = {
|
|
2582
4622
|
/**
|
|
4623
|
+
* Response Add Tags To Workflow V1 Workflows Workflow Id Tags Post
|
|
4624
|
+
*
|
|
2583
4625
|
* Successful Response
|
|
2584
4626
|
*/
|
|
2585
4627
|
200: Array<WorkflowTagResponse>;
|
|
@@ -2594,7 +4636,13 @@ export type RemoveTagFromWorkflowV1WorkflowsWorkflowIdTagsTagIdDeleteData = {
|
|
|
2594
4636
|
'Idempotency-Key'?: string;
|
|
2595
4637
|
};
|
|
2596
4638
|
path: {
|
|
4639
|
+
/**
|
|
4640
|
+
* Workflow Id
|
|
4641
|
+
*/
|
|
2597
4642
|
workflow_id: string;
|
|
4643
|
+
/**
|
|
4644
|
+
* Tag Id
|
|
4645
|
+
*/
|
|
2598
4646
|
tag_id: string;
|
|
2599
4647
|
};
|
|
2600
4648
|
query?: never;
|
|
@@ -2619,6 +4667,8 @@ export type ListTagsV1WorkflowTagsGetData = {
|
|
|
2619
4667
|
path?: never;
|
|
2620
4668
|
query?: {
|
|
2621
4669
|
/**
|
|
4670
|
+
* Include Archived
|
|
4671
|
+
*
|
|
2622
4672
|
* Include archived tags in the response
|
|
2623
4673
|
*/
|
|
2624
4674
|
include_archived?: boolean;
|
|
@@ -2634,6 +4684,8 @@ export type ListTagsV1WorkflowTagsGetErrors = {
|
|
|
2634
4684
|
export type ListTagsV1WorkflowTagsGetError = ListTagsV1WorkflowTagsGetErrors[keyof ListTagsV1WorkflowTagsGetErrors];
|
|
2635
4685
|
export type ListTagsV1WorkflowTagsGetResponses = {
|
|
2636
4686
|
/**
|
|
4687
|
+
* Response List Tags V1 Workflow Tags Get
|
|
4688
|
+
*
|
|
2637
4689
|
* Successful Response
|
|
2638
4690
|
*/
|
|
2639
4691
|
200: Array<WorkflowTagResponse>;
|
|
@@ -2674,6 +4726,9 @@ export type DeleteTagV1WorkflowTagsTagIdDeleteData = {
|
|
|
2674
4726
|
'Idempotency-Key'?: string;
|
|
2675
4727
|
};
|
|
2676
4728
|
path: {
|
|
4729
|
+
/**
|
|
4730
|
+
* Tag Id
|
|
4731
|
+
*/
|
|
2677
4732
|
tag_id: string;
|
|
2678
4733
|
};
|
|
2679
4734
|
query?: never;
|
|
@@ -2696,6 +4751,9 @@ export type DeleteTagV1WorkflowTagsTagIdDeleteResponse = DeleteTagV1WorkflowTags
|
|
|
2696
4751
|
export type GetTagV1WorkflowTagsTagIdGetData = {
|
|
2697
4752
|
body?: never;
|
|
2698
4753
|
path: {
|
|
4754
|
+
/**
|
|
4755
|
+
* Tag Id
|
|
4756
|
+
*/
|
|
2699
4757
|
tag_id: string;
|
|
2700
4758
|
};
|
|
2701
4759
|
query?: never;
|
|
@@ -2724,6 +4782,9 @@ export type UpdateTagV1WorkflowTagsTagIdPatchData = {
|
|
|
2724
4782
|
'Idempotency-Key'?: string;
|
|
2725
4783
|
};
|
|
2726
4784
|
path: {
|
|
4785
|
+
/**
|
|
4786
|
+
* Tag Id
|
|
4787
|
+
*/
|
|
2727
4788
|
tag_id: string;
|
|
2728
4789
|
};
|
|
2729
4790
|
query?: never;
|
|
@@ -2752,6 +4813,9 @@ export type ArchiveTagV1WorkflowTagsTagIdArchivePostData = {
|
|
|
2752
4813
|
'Idempotency-Key'?: string;
|
|
2753
4814
|
};
|
|
2754
4815
|
path: {
|
|
4816
|
+
/**
|
|
4817
|
+
* Tag Id
|
|
4818
|
+
*/
|
|
2755
4819
|
tag_id: string;
|
|
2756
4820
|
};
|
|
2757
4821
|
query?: never;
|
|
@@ -2780,6 +4844,9 @@ export type UnarchiveTagV1WorkflowTagsTagIdUnarchivePostData = {
|
|
|
2780
4844
|
'Idempotency-Key'?: string;
|
|
2781
4845
|
};
|
|
2782
4846
|
path: {
|
|
4847
|
+
/**
|
|
4848
|
+
* Tag Id
|
|
4849
|
+
*/
|
|
2783
4850
|
tag_id: string;
|
|
2784
4851
|
};
|
|
2785
4852
|
query?: never;
|
|
@@ -2833,6 +4900,8 @@ export type ListTagGroupsV1WorkflowTagGroupsGetData = {
|
|
|
2833
4900
|
};
|
|
2834
4901
|
export type ListTagGroupsV1WorkflowTagGroupsGetResponses = {
|
|
2835
4902
|
/**
|
|
4903
|
+
* Response List Tag Groups V1 Workflow Tag Groups Get
|
|
4904
|
+
*
|
|
2836
4905
|
* Successful Response
|
|
2837
4906
|
*/
|
|
2838
4907
|
200: Array<WorkflowTagGroupResponse>;
|
|
@@ -2873,6 +4942,9 @@ export type DeleteTagGroupV1WorkflowTagGroupsGroupIdDeleteData = {
|
|
|
2873
4942
|
'Idempotency-Key'?: string;
|
|
2874
4943
|
};
|
|
2875
4944
|
path: {
|
|
4945
|
+
/**
|
|
4946
|
+
* Group Id
|
|
4947
|
+
*/
|
|
2876
4948
|
group_id: string;
|
|
2877
4949
|
};
|
|
2878
4950
|
query?: never;
|
|
@@ -2895,6 +4967,9 @@ export type DeleteTagGroupV1WorkflowTagGroupsGroupIdDeleteResponse = DeleteTagGr
|
|
|
2895
4967
|
export type GetTagGroupV1WorkflowTagGroupsGroupIdGetData = {
|
|
2896
4968
|
body?: never;
|
|
2897
4969
|
path: {
|
|
4970
|
+
/**
|
|
4971
|
+
* Group Id
|
|
4972
|
+
*/
|
|
2898
4973
|
group_id: string;
|
|
2899
4974
|
};
|
|
2900
4975
|
query?: never;
|
|
@@ -2923,6 +4998,9 @@ export type UpdateTagGroupV1WorkflowTagGroupsGroupIdPatchData = {
|
|
|
2923
4998
|
'Idempotency-Key'?: string;
|
|
2924
4999
|
};
|
|
2925
5000
|
path: {
|
|
5001
|
+
/**
|
|
5002
|
+
* Group Id
|
|
5003
|
+
*/
|
|
2926
5004
|
group_id: string;
|
|
2927
5005
|
};
|
|
2928
5006
|
query?: never;
|
|
@@ -2976,6 +5054,8 @@ export type ListModelConfigurationsV1ModelConfigurationsGetData = {
|
|
|
2976
5054
|
};
|
|
2977
5055
|
export type ListModelConfigurationsV1ModelConfigurationsGetResponses = {
|
|
2978
5056
|
/**
|
|
5057
|
+
* Response List Model Configurations V1 Model Configurations Get
|
|
5058
|
+
*
|
|
2979
5059
|
* Successful Response
|
|
2980
5060
|
*/
|
|
2981
5061
|
200: Array<ModelConfigurationResponse>;
|
|
@@ -3016,6 +5096,9 @@ export type DeleteModelConfigurationV1ModelConfigurationsModelConfigurationIdDel
|
|
|
3016
5096
|
'Idempotency-Key'?: string;
|
|
3017
5097
|
};
|
|
3018
5098
|
path: {
|
|
5099
|
+
/**
|
|
5100
|
+
* Model Configuration Id
|
|
5101
|
+
*/
|
|
3019
5102
|
model_configuration_id: string;
|
|
3020
5103
|
};
|
|
3021
5104
|
query?: never;
|
|
@@ -3038,6 +5121,9 @@ export type DeleteModelConfigurationV1ModelConfigurationsModelConfigurationIdDel
|
|
|
3038
5121
|
export type GetModelConfigurationV1ModelConfigurationsModelConfigurationIdGetData = {
|
|
3039
5122
|
body?: never;
|
|
3040
5123
|
path: {
|
|
5124
|
+
/**
|
|
5125
|
+
* Model Configuration Id
|
|
5126
|
+
*/
|
|
3041
5127
|
model_configuration_id: string;
|
|
3042
5128
|
};
|
|
3043
5129
|
query?: never;
|
|
@@ -3066,6 +5152,9 @@ export type UpdateModelConfigurationV1ModelConfigurationsModelConfigurationIdPat
|
|
|
3066
5152
|
'Idempotency-Key'?: string;
|
|
3067
5153
|
};
|
|
3068
5154
|
path: {
|
|
5155
|
+
/**
|
|
5156
|
+
* Model Configuration Id
|
|
5157
|
+
*/
|
|
3069
5158
|
model_configuration_id: string;
|
|
3070
5159
|
};
|
|
3071
5160
|
query?: never;
|
|
@@ -3090,26 +5179,38 @@ export type ListRunsV1RunsGetData = {
|
|
|
3090
5179
|
path?: never;
|
|
3091
5180
|
query?: {
|
|
3092
5181
|
/**
|
|
5182
|
+
* Workflow Id
|
|
5183
|
+
*
|
|
3093
5184
|
* Filter by workflow ID
|
|
3094
5185
|
*/
|
|
3095
5186
|
workflow_id?: string | null;
|
|
3096
5187
|
/**
|
|
5188
|
+
* Machine Id
|
|
5189
|
+
*
|
|
3097
5190
|
* Filter by machine ID
|
|
3098
5191
|
*/
|
|
3099
5192
|
machine_id?: string | null;
|
|
3100
5193
|
/**
|
|
5194
|
+
* Session Id
|
|
5195
|
+
*
|
|
3101
5196
|
* Filter by session ID
|
|
3102
5197
|
*/
|
|
3103
5198
|
session_id?: string | null;
|
|
3104
5199
|
/**
|
|
5200
|
+
* Status
|
|
5201
|
+
*
|
|
3105
5202
|
* Filter by run status
|
|
3106
5203
|
*/
|
|
3107
5204
|
status?: RunStatus | null;
|
|
3108
5205
|
/**
|
|
5206
|
+
* Created At From
|
|
5207
|
+
*
|
|
3109
5208
|
* Filter runs created at or after this ISO timestamp (UTC)
|
|
3110
5209
|
*/
|
|
3111
5210
|
created_at_from?: string | null;
|
|
3112
5211
|
/**
|
|
5212
|
+
* Created At To
|
|
5213
|
+
*
|
|
3113
5214
|
* Filter runs created at or before this ISO timestamp (UTC)
|
|
3114
5215
|
*/
|
|
3115
5216
|
created_at_to?: string | null;
|
|
@@ -3118,22 +5219,36 @@ export type ListRunsV1RunsGetData = {
|
|
|
3118
5219
|
*/
|
|
3119
5220
|
sort_mode?: RunListSortMode;
|
|
3120
5221
|
/**
|
|
5222
|
+
* Search
|
|
5223
|
+
*
|
|
3121
5224
|
* Search runs by id, input_values, output_data, error, session_alias (case-insensitive substring match)
|
|
3122
5225
|
*/
|
|
3123
5226
|
search?: string | null;
|
|
3124
5227
|
/**
|
|
5228
|
+
* Deep Search
|
|
5229
|
+
*
|
|
3125
5230
|
* If true, also search run_message_history (slower but more comprehensive)
|
|
3126
5231
|
*/
|
|
3127
5232
|
deep_search?: boolean;
|
|
3128
5233
|
/**
|
|
5234
|
+
* Fields
|
|
5235
|
+
*
|
|
3129
5236
|
* Optional list of fields to include per run. Always includes: id, workflow_id, machine_id, status, created_at. Provide multiple 'fields=' params to include more.
|
|
3130
5237
|
*/
|
|
3131
5238
|
fields?: Array<RunField> | null;
|
|
3132
5239
|
/**
|
|
5240
|
+
* Include
|
|
5241
|
+
*
|
|
3133
5242
|
* Comma-separated list of related resources to include. Allowed values: workflow, machine, machine.pools. Example: include=workflow,machine
|
|
3134
5243
|
*/
|
|
3135
5244
|
include?: string | null;
|
|
5245
|
+
/**
|
|
5246
|
+
* Skip
|
|
5247
|
+
*/
|
|
3136
5248
|
skip?: number;
|
|
5249
|
+
/**
|
|
5250
|
+
* Limit
|
|
5251
|
+
*/
|
|
3137
5252
|
limit?: number;
|
|
3138
5253
|
};
|
|
3139
5254
|
url: '/v1/runs';
|
|
@@ -3187,6 +5302,9 @@ export type DeleteRunV1RunsRunIdDeleteData = {
|
|
|
3187
5302
|
'Idempotency-Key'?: string;
|
|
3188
5303
|
};
|
|
3189
5304
|
path: {
|
|
5305
|
+
/**
|
|
5306
|
+
* Run Id
|
|
5307
|
+
*/
|
|
3190
5308
|
run_id: string;
|
|
3191
5309
|
};
|
|
3192
5310
|
query?: never;
|
|
@@ -3209,10 +5327,15 @@ export type DeleteRunV1RunsRunIdDeleteResponse = DeleteRunV1RunsRunIdDeleteRespo
|
|
|
3209
5327
|
export type GetRunV1RunsRunIdGetData = {
|
|
3210
5328
|
body?: never;
|
|
3211
5329
|
path: {
|
|
5330
|
+
/**
|
|
5331
|
+
* Run Id
|
|
5332
|
+
*/
|
|
3212
5333
|
run_id: string;
|
|
3213
5334
|
};
|
|
3214
5335
|
query?: {
|
|
3215
5336
|
/**
|
|
5337
|
+
* Include
|
|
5338
|
+
*
|
|
3216
5339
|
* Comma-separated list of related resources to include. Allowed values: workflow, machine, machine.pools. Example: include=workflow,machine
|
|
3217
5340
|
*/
|
|
3218
5341
|
include?: string | null;
|
|
@@ -3242,6 +5365,9 @@ export type UpdateRunV1RunsRunIdPatchData = {
|
|
|
3242
5365
|
'Idempotency-Key'?: string;
|
|
3243
5366
|
};
|
|
3244
5367
|
path: {
|
|
5368
|
+
/**
|
|
5369
|
+
* Run Id
|
|
5370
|
+
*/
|
|
3245
5371
|
run_id: string;
|
|
3246
5372
|
};
|
|
3247
5373
|
query?: never;
|
|
@@ -3264,6 +5390,9 @@ export type UpdateRunV1RunsRunIdPatchResponse = UpdateRunV1RunsRunIdPatchRespons
|
|
|
3264
5390
|
export type GetRunTrajectoryV1RunsRunIdTrajectoryGetData = {
|
|
3265
5391
|
body?: never;
|
|
3266
5392
|
path: {
|
|
5393
|
+
/**
|
|
5394
|
+
* Run Id
|
|
5395
|
+
*/
|
|
3267
5396
|
run_id: string;
|
|
3268
5397
|
};
|
|
3269
5398
|
query?: never;
|
|
@@ -3292,6 +5421,9 @@ export type GenerateRunTrajectoryV1RunsRunIdGenerateTrajectoryPostData = {
|
|
|
3292
5421
|
'Idempotency-Key'?: string;
|
|
3293
5422
|
};
|
|
3294
5423
|
path: {
|
|
5424
|
+
/**
|
|
5425
|
+
* Run Id
|
|
5426
|
+
*/
|
|
3295
5427
|
run_id: string;
|
|
3296
5428
|
};
|
|
3297
5429
|
query?: never;
|
|
@@ -3372,6 +5504,9 @@ export type RetryRunV1RunsRunIdRetryPostData = {
|
|
|
3372
5504
|
'Idempotency-Key'?: string;
|
|
3373
5505
|
};
|
|
3374
5506
|
path: {
|
|
5507
|
+
/**
|
|
5508
|
+
* Run Id
|
|
5509
|
+
*/
|
|
3375
5510
|
run_id: string;
|
|
3376
5511
|
};
|
|
3377
5512
|
query?: never;
|
|
@@ -3396,14 +5531,24 @@ export type ListRunAttachmentsV1RunAttachmentsGetData = {
|
|
|
3396
5531
|
path?: never;
|
|
3397
5532
|
query?: {
|
|
3398
5533
|
/**
|
|
5534
|
+
* Run Id
|
|
5535
|
+
*
|
|
3399
5536
|
* Filter by run ID
|
|
3400
5537
|
*/
|
|
3401
5538
|
run_id?: string | null;
|
|
3402
5539
|
/**
|
|
5540
|
+
* Attachment Type
|
|
5541
|
+
*
|
|
3403
5542
|
* Filter by attachment type
|
|
3404
5543
|
*/
|
|
3405
5544
|
attachment_type?: AttachmentType | null;
|
|
5545
|
+
/**
|
|
5546
|
+
* Skip
|
|
5547
|
+
*/
|
|
3406
5548
|
skip?: number;
|
|
5549
|
+
/**
|
|
5550
|
+
* Limit
|
|
5551
|
+
*/
|
|
3407
5552
|
limit?: number;
|
|
3408
5553
|
};
|
|
3409
5554
|
url: '/v1/run-attachments';
|
|
@@ -3457,6 +5602,9 @@ export type DeleteRunAttachmentV1RunAttachmentsAttachmentIdDeleteData = {
|
|
|
3457
5602
|
'Idempotency-Key'?: string;
|
|
3458
5603
|
};
|
|
3459
5604
|
path: {
|
|
5605
|
+
/**
|
|
5606
|
+
* Attachment Id
|
|
5607
|
+
*/
|
|
3460
5608
|
attachment_id: string;
|
|
3461
5609
|
};
|
|
3462
5610
|
query?: never;
|
|
@@ -3479,6 +5627,9 @@ export type DeleteRunAttachmentV1RunAttachmentsAttachmentIdDeleteResponse = Dele
|
|
|
3479
5627
|
export type GetRunAttachmentV1RunAttachmentsAttachmentIdGetData = {
|
|
3480
5628
|
body?: never;
|
|
3481
5629
|
path: {
|
|
5630
|
+
/**
|
|
5631
|
+
* Attachment Id
|
|
5632
|
+
*/
|
|
3482
5633
|
attachment_id: string;
|
|
3483
5634
|
};
|
|
3484
5635
|
query?: never;
|
|
@@ -3507,6 +5658,9 @@ export type UpdateRunAttachmentV1RunAttachmentsAttachmentIdPutData = {
|
|
|
3507
5658
|
'Idempotency-Key'?: string;
|
|
3508
5659
|
};
|
|
3509
5660
|
path: {
|
|
5661
|
+
/**
|
|
5662
|
+
* Attachment Id
|
|
5663
|
+
*/
|
|
3510
5664
|
attachment_id: string;
|
|
3511
5665
|
};
|
|
3512
5666
|
query?: never;
|
|
@@ -3529,10 +5683,15 @@ export type UpdateRunAttachmentV1RunAttachmentsAttachmentIdPutResponse = UpdateR
|
|
|
3529
5683
|
export type GetRunAttachmentDownloadUrlV1RunAttachmentsAttachmentIdDownloadUrlGetData = {
|
|
3530
5684
|
body?: never;
|
|
3531
5685
|
path: {
|
|
5686
|
+
/**
|
|
5687
|
+
* Attachment Id
|
|
5688
|
+
*/
|
|
3532
5689
|
attachment_id: string;
|
|
3533
5690
|
};
|
|
3534
5691
|
query?: {
|
|
3535
5692
|
/**
|
|
5693
|
+
* Expires In
|
|
5694
|
+
*
|
|
3536
5695
|
* URL expiration time in seconds (10-3600)
|
|
3537
5696
|
*/
|
|
3538
5697
|
expires_in?: number;
|
|
@@ -3556,6 +5715,9 @@ export type GetRunAttachmentDownloadUrlV1RunAttachmentsAttachmentIdDownloadUrlGe
|
|
|
3556
5715
|
export type DownloadRunAttachmentV1RunAttachmentsAttachmentIdDownloadGetData = {
|
|
3557
5716
|
body?: never;
|
|
3558
5717
|
path: {
|
|
5718
|
+
/**
|
|
5719
|
+
* Attachment Id
|
|
5720
|
+
*/
|
|
3559
5721
|
attachment_id: string;
|
|
3560
5722
|
};
|
|
3561
5723
|
query?: never;
|
|
@@ -3580,14 +5742,24 @@ export type ListConnectionsV1ConnectionsGetData = {
|
|
|
3580
5742
|
path?: never;
|
|
3581
5743
|
query?: {
|
|
3582
5744
|
/**
|
|
5745
|
+
* Machine Id
|
|
5746
|
+
*
|
|
3583
5747
|
* Filter by machine ID
|
|
3584
5748
|
*/
|
|
3585
5749
|
machine_id?: string | null;
|
|
3586
5750
|
/**
|
|
5751
|
+
* Status
|
|
5752
|
+
*
|
|
3587
5753
|
* Filter by connection status
|
|
3588
5754
|
*/
|
|
3589
5755
|
status?: ConnectionStatus | null;
|
|
5756
|
+
/**
|
|
5757
|
+
* Skip
|
|
5758
|
+
*/
|
|
3590
5759
|
skip?: number;
|
|
5760
|
+
/**
|
|
5761
|
+
* Limit
|
|
5762
|
+
*/
|
|
3591
5763
|
limit?: number;
|
|
3592
5764
|
};
|
|
3593
5765
|
url: '/v1/connections';
|
|
@@ -3641,6 +5813,9 @@ export type DeleteConnectionV1ConnectionsConnectionIdDeleteData = {
|
|
|
3641
5813
|
'Idempotency-Key'?: string;
|
|
3642
5814
|
};
|
|
3643
5815
|
path: {
|
|
5816
|
+
/**
|
|
5817
|
+
* Connection Id
|
|
5818
|
+
*/
|
|
3644
5819
|
connection_id: string;
|
|
3645
5820
|
};
|
|
3646
5821
|
query?: never;
|
|
@@ -3663,6 +5838,9 @@ export type DeleteConnectionV1ConnectionsConnectionIdDeleteResponse = DeleteConn
|
|
|
3663
5838
|
export type GetConnectionV1ConnectionsConnectionIdGetData = {
|
|
3664
5839
|
body?: never;
|
|
3665
5840
|
path: {
|
|
5841
|
+
/**
|
|
5842
|
+
* Connection Id
|
|
5843
|
+
*/
|
|
3666
5844
|
connection_id: string;
|
|
3667
5845
|
};
|
|
3668
5846
|
query?: never;
|
|
@@ -3691,6 +5869,9 @@ export type UpdateConnectionV1ConnectionsConnectionIdPatchData = {
|
|
|
3691
5869
|
'Idempotency-Key'?: string;
|
|
3692
5870
|
};
|
|
3693
5871
|
path: {
|
|
5872
|
+
/**
|
|
5873
|
+
* Connection Id
|
|
5874
|
+
*/
|
|
3694
5875
|
connection_id: string;
|
|
3695
5876
|
};
|
|
3696
5877
|
query?: never;
|
|
@@ -3715,18 +5896,30 @@ export type ListRequestLogsV1RequestLogsGetData = {
|
|
|
3715
5896
|
path?: never;
|
|
3716
5897
|
query?: {
|
|
3717
5898
|
/**
|
|
5899
|
+
* Machine Id
|
|
5900
|
+
*
|
|
3718
5901
|
* Filter by machine ID
|
|
3719
5902
|
*/
|
|
3720
5903
|
machine_id?: string | null;
|
|
3721
5904
|
/**
|
|
5905
|
+
* Method
|
|
5906
|
+
*
|
|
3722
5907
|
* Filter by HTTP method
|
|
3723
5908
|
*/
|
|
3724
5909
|
method?: string | null;
|
|
3725
5910
|
/**
|
|
5911
|
+
* Status Code
|
|
5912
|
+
*
|
|
3726
5913
|
* Filter by status code
|
|
3727
5914
|
*/
|
|
3728
5915
|
status_code?: number | null;
|
|
5916
|
+
/**
|
|
5917
|
+
* Skip
|
|
5918
|
+
*/
|
|
3729
5919
|
skip?: number;
|
|
5920
|
+
/**
|
|
5921
|
+
* Limit
|
|
5922
|
+
*/
|
|
3730
5923
|
limit?: number;
|
|
3731
5924
|
};
|
|
3732
5925
|
url: '/v1/request-logs';
|
|
@@ -3780,6 +5973,9 @@ export type DeleteRequestLogV1RequestLogsLogIdDeleteData = {
|
|
|
3780
5973
|
'Idempotency-Key'?: string;
|
|
3781
5974
|
};
|
|
3782
5975
|
path: {
|
|
5976
|
+
/**
|
|
5977
|
+
* Log Id
|
|
5978
|
+
*/
|
|
3783
5979
|
log_id: string;
|
|
3784
5980
|
};
|
|
3785
5981
|
query?: never;
|
|
@@ -3802,6 +5998,9 @@ export type DeleteRequestLogV1RequestLogsLogIdDeleteResponse = DeleteRequestLogV
|
|
|
3802
5998
|
export type GetRequestLogV1RequestLogsLogIdGetData = {
|
|
3803
5999
|
body?: never;
|
|
3804
6000
|
path: {
|
|
6001
|
+
/**
|
|
6002
|
+
* Log Id
|
|
6003
|
+
*/
|
|
3805
6004
|
log_id: string;
|
|
3806
6005
|
};
|
|
3807
6006
|
query?: never;
|
|
@@ -3830,6 +6029,9 @@ export type UpdateRequestLogV1RequestLogsLogIdPatchData = {
|
|
|
3830
6029
|
'Idempotency-Key'?: string;
|
|
3831
6030
|
};
|
|
3832
6031
|
path: {
|
|
6032
|
+
/**
|
|
6033
|
+
* Log Id
|
|
6034
|
+
*/
|
|
3833
6035
|
log_id: string;
|
|
3834
6036
|
};
|
|
3835
6037
|
query?: never;
|
|
@@ -3854,46 +6056,72 @@ export type ListTrajectoriesV1TrajectoriesGetData = {
|
|
|
3854
6056
|
path?: never;
|
|
3855
6057
|
query?: {
|
|
3856
6058
|
/**
|
|
6059
|
+
* Search
|
|
6060
|
+
*
|
|
3857
6061
|
* Search trajectories by id, name, or description (case-insensitive substring match)
|
|
3858
6062
|
*/
|
|
3859
6063
|
search?: string | null;
|
|
3860
6064
|
/**
|
|
6065
|
+
* Workflow Id
|
|
6066
|
+
*
|
|
3861
6067
|
* Filter by workflow ID
|
|
3862
6068
|
*/
|
|
3863
6069
|
workflow_id?: string | null;
|
|
3864
6070
|
/**
|
|
6071
|
+
* Run Id
|
|
6072
|
+
*
|
|
3865
6073
|
* Filter by run ID
|
|
3866
6074
|
*/
|
|
3867
6075
|
run_id?: string | null;
|
|
3868
6076
|
/**
|
|
6077
|
+
* Is Approved
|
|
6078
|
+
*
|
|
3869
6079
|
* Filter by approval status (true=approved, false=not approved)
|
|
3870
6080
|
*/
|
|
3871
6081
|
is_approved?: boolean | null;
|
|
3872
6082
|
/**
|
|
6083
|
+
* Is Generated
|
|
6084
|
+
*
|
|
3873
6085
|
* Filter by generated status (true=generated, false=pending generation). Defaults to true.
|
|
3874
6086
|
*/
|
|
3875
6087
|
is_generated?: boolean | null;
|
|
3876
6088
|
/**
|
|
6089
|
+
* Created At From
|
|
6090
|
+
*
|
|
3877
6091
|
* Filter trajectories created at or after this ISO timestamp (UTC)
|
|
3878
6092
|
*/
|
|
3879
6093
|
created_at_from?: string | null;
|
|
3880
6094
|
/**
|
|
6095
|
+
* Created At To
|
|
6096
|
+
*
|
|
3881
6097
|
* Filter trajectories created at or before this ISO timestamp (UTC)
|
|
3882
6098
|
*/
|
|
3883
6099
|
created_at_to?: string | null;
|
|
3884
6100
|
/**
|
|
6101
|
+
* Updated At From
|
|
6102
|
+
*
|
|
3885
6103
|
* Filter trajectories updated at or after this ISO timestamp (UTC)
|
|
3886
6104
|
*/
|
|
3887
6105
|
updated_at_from?: string | null;
|
|
3888
6106
|
/**
|
|
6107
|
+
* Updated At To
|
|
6108
|
+
*
|
|
3889
6109
|
* Filter trajectories updated at or before this ISO timestamp (UTC)
|
|
3890
6110
|
*/
|
|
3891
6111
|
updated_at_to?: string | null;
|
|
3892
6112
|
/**
|
|
6113
|
+
* Include
|
|
6114
|
+
*
|
|
3893
6115
|
* Comma-separated list of related resources to include. Allowed values: workflow. Example: include=workflow
|
|
3894
6116
|
*/
|
|
3895
6117
|
include?: string | null;
|
|
6118
|
+
/**
|
|
6119
|
+
* Skip
|
|
6120
|
+
*/
|
|
3896
6121
|
skip?: number;
|
|
6122
|
+
/**
|
|
6123
|
+
* Limit
|
|
6124
|
+
*/
|
|
3897
6125
|
limit?: number;
|
|
3898
6126
|
};
|
|
3899
6127
|
url: '/v1/trajectories';
|
|
@@ -3947,6 +6175,9 @@ export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteData = {
|
|
|
3947
6175
|
'Idempotency-Key'?: string;
|
|
3948
6176
|
};
|
|
3949
6177
|
path: {
|
|
6178
|
+
/**
|
|
6179
|
+
* Trajectory Id
|
|
6180
|
+
*/
|
|
3950
6181
|
trajectory_id: string;
|
|
3951
6182
|
};
|
|
3952
6183
|
query?: never;
|
|
@@ -3969,10 +6200,15 @@ export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteResponse = DeleteTra
|
|
|
3969
6200
|
export type GetTrajectoryV1TrajectoriesTrajectoryIdGetData = {
|
|
3970
6201
|
body?: never;
|
|
3971
6202
|
path: {
|
|
6203
|
+
/**
|
|
6204
|
+
* Trajectory Id
|
|
6205
|
+
*/
|
|
3972
6206
|
trajectory_id: string;
|
|
3973
6207
|
};
|
|
3974
6208
|
query?: {
|
|
3975
6209
|
/**
|
|
6210
|
+
* Include
|
|
6211
|
+
*
|
|
3976
6212
|
* Comma-separated list of related resources to include. Allowed values: workflow. Example: include=workflow
|
|
3977
6213
|
*/
|
|
3978
6214
|
include?: string | null;
|
|
@@ -4002,6 +6238,9 @@ export type UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchData = {
|
|
|
4002
6238
|
'Idempotency-Key'?: string;
|
|
4003
6239
|
};
|
|
4004
6240
|
path: {
|
|
6241
|
+
/**
|
|
6242
|
+
* Trajectory Id
|
|
6243
|
+
*/
|
|
4005
6244
|
trajectory_id: string;
|
|
4006
6245
|
};
|
|
4007
6246
|
query?: never;
|
|
@@ -4030,6 +6269,9 @@ export type DuplicateTrajectoryV1TrajectoriesTrajectoryIdDuplicatePostData = {
|
|
|
4030
6269
|
'Idempotency-Key'?: string;
|
|
4031
6270
|
};
|
|
4032
6271
|
path: {
|
|
6272
|
+
/**
|
|
6273
|
+
* Trajectory Id
|
|
6274
|
+
*/
|
|
4033
6275
|
trajectory_id: string;
|
|
4034
6276
|
};
|
|
4035
6277
|
query?: never;
|
|
@@ -4052,6 +6294,9 @@ export type DuplicateTrajectoryV1TrajectoriesTrajectoryIdDuplicatePostResponse =
|
|
|
4052
6294
|
export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetData = {
|
|
4053
6295
|
body?: never;
|
|
4054
6296
|
path: {
|
|
6297
|
+
/**
|
|
6298
|
+
* Workflow Id
|
|
6299
|
+
*/
|
|
4055
6300
|
workflow_id: string;
|
|
4056
6301
|
};
|
|
4057
6302
|
query?: never;
|
|
@@ -4074,6 +6319,9 @@ export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryG
|
|
|
4074
6319
|
export type GetScreenshotV1ComputerMachineIdDisplayScreenshotGetData = {
|
|
4075
6320
|
body?: never;
|
|
4076
6321
|
path: {
|
|
6322
|
+
/**
|
|
6323
|
+
* Machine Id
|
|
6324
|
+
*/
|
|
4077
6325
|
machine_id: string;
|
|
4078
6326
|
};
|
|
4079
6327
|
query?: never;
|
|
@@ -4095,6 +6343,9 @@ export type GetScreenshotV1ComputerMachineIdDisplayScreenshotGetResponses = {
|
|
|
4095
6343
|
export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetData = {
|
|
4096
6344
|
body?: never;
|
|
4097
6345
|
path: {
|
|
6346
|
+
/**
|
|
6347
|
+
* Machine Id
|
|
6348
|
+
*/
|
|
4098
6349
|
machine_id: string;
|
|
4099
6350
|
};
|
|
4100
6351
|
query?: never;
|
|
@@ -4123,6 +6374,9 @@ export type KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostData = {
|
|
|
4123
6374
|
'Idempotency-Key'?: string;
|
|
4124
6375
|
};
|
|
4125
6376
|
path: {
|
|
6377
|
+
/**
|
|
6378
|
+
* Machine Id
|
|
6379
|
+
*/
|
|
4126
6380
|
machine_id: string;
|
|
4127
6381
|
};
|
|
4128
6382
|
query?: never;
|
|
@@ -4151,6 +6405,9 @@ export type KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostData = {
|
|
|
4151
6405
|
'Idempotency-Key'?: string;
|
|
4152
6406
|
};
|
|
4153
6407
|
path: {
|
|
6408
|
+
/**
|
|
6409
|
+
* Machine Id
|
|
6410
|
+
*/
|
|
4154
6411
|
machine_id: string;
|
|
4155
6412
|
};
|
|
4156
6413
|
query?: never;
|
|
@@ -4179,6 +6436,9 @@ export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostData = {
|
|
|
4179
6436
|
'Idempotency-Key'?: string;
|
|
4180
6437
|
};
|
|
4181
6438
|
path: {
|
|
6439
|
+
/**
|
|
6440
|
+
* Machine Id
|
|
6441
|
+
*/
|
|
4182
6442
|
machine_id: string;
|
|
4183
6443
|
};
|
|
4184
6444
|
query?: never;
|
|
@@ -4193,6 +6453,8 @@ export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostErrors = {
|
|
|
4193
6453
|
export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostError = CopyToClipboardV1ComputerMachineIdCopyToClipboardPostErrors[keyof CopyToClipboardV1ComputerMachineIdCopyToClipboardPostErrors];
|
|
4194
6454
|
export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostResponses = {
|
|
4195
6455
|
/**
|
|
6456
|
+
* Response Copy To Clipboard V1 Computer Machine Id Copy To Clipboard Post
|
|
6457
|
+
*
|
|
4196
6458
|
* Successful Response
|
|
4197
6459
|
*/
|
|
4198
6460
|
200: {
|
|
@@ -4203,6 +6465,9 @@ export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostResponse = Copy
|
|
|
4203
6465
|
export type GetMousePositionV1ComputerMachineIdInputMousePositionGetData = {
|
|
4204
6466
|
body?: never;
|
|
4205
6467
|
path: {
|
|
6468
|
+
/**
|
|
6469
|
+
* Machine Id
|
|
6470
|
+
*/
|
|
4206
6471
|
machine_id: string;
|
|
4207
6472
|
};
|
|
4208
6473
|
query?: never;
|
|
@@ -4231,6 +6496,9 @@ export type MouseMoveV1ComputerMachineIdInputMouseMovePostData = {
|
|
|
4231
6496
|
'Idempotency-Key'?: string;
|
|
4232
6497
|
};
|
|
4233
6498
|
path: {
|
|
6499
|
+
/**
|
|
6500
|
+
* Machine Id
|
|
6501
|
+
*/
|
|
4234
6502
|
machine_id: string;
|
|
4235
6503
|
};
|
|
4236
6504
|
query?: never;
|
|
@@ -4259,6 +6527,9 @@ export type MouseClickV1ComputerMachineIdInputMouseClickPostData = {
|
|
|
4259
6527
|
'Idempotency-Key'?: string;
|
|
4260
6528
|
};
|
|
4261
6529
|
path: {
|
|
6530
|
+
/**
|
|
6531
|
+
* Machine Id
|
|
6532
|
+
*/
|
|
4262
6533
|
machine_id: string;
|
|
4263
6534
|
};
|
|
4264
6535
|
query?: never;
|
|
@@ -4287,6 +6558,9 @@ export type MouseScrollV1ComputerMachineIdInputMouseScrollPostData = {
|
|
|
4287
6558
|
'Idempotency-Key'?: string;
|
|
4288
6559
|
};
|
|
4289
6560
|
path: {
|
|
6561
|
+
/**
|
|
6562
|
+
* Machine Id
|
|
6563
|
+
*/
|
|
4290
6564
|
machine_id: string;
|
|
4291
6565
|
};
|
|
4292
6566
|
query?: never;
|
|
@@ -4315,6 +6589,9 @@ export type MouseDragV1ComputerMachineIdInputMouseDragPostData = {
|
|
|
4315
6589
|
'Idempotency-Key'?: string;
|
|
4316
6590
|
};
|
|
4317
6591
|
path: {
|
|
6592
|
+
/**
|
|
6593
|
+
* Machine Id
|
|
6594
|
+
*/
|
|
4318
6595
|
machine_id: string;
|
|
4319
6596
|
};
|
|
4320
6597
|
query?: never;
|
|
@@ -4337,9 +6614,15 @@ export type MouseDragV1ComputerMachineIdInputMouseDragPostResponse = MouseDragV1
|
|
|
4337
6614
|
export type FsListV1ComputerMachineIdFsListGetData = {
|
|
4338
6615
|
body?: never;
|
|
4339
6616
|
path: {
|
|
6617
|
+
/**
|
|
6618
|
+
* Machine Id
|
|
6619
|
+
*/
|
|
4340
6620
|
machine_id: string;
|
|
4341
6621
|
};
|
|
4342
6622
|
query?: {
|
|
6623
|
+
/**
|
|
6624
|
+
* Path
|
|
6625
|
+
*/
|
|
4343
6626
|
path?: string;
|
|
4344
6627
|
};
|
|
4345
6628
|
url: '/v1/computer/{machine_id}/fs/list';
|
|
@@ -4353,6 +6636,8 @@ export type FsListV1ComputerMachineIdFsListGetErrors = {
|
|
|
4353
6636
|
export type FsListV1ComputerMachineIdFsListGetError = FsListV1ComputerMachineIdFsListGetErrors[keyof FsListV1ComputerMachineIdFsListGetErrors];
|
|
4354
6637
|
export type FsListV1ComputerMachineIdFsListGetResponses = {
|
|
4355
6638
|
/**
|
|
6639
|
+
* Response Fs List V1 Computer Machine Id Fs List Get
|
|
6640
|
+
*
|
|
4356
6641
|
* Successful Response
|
|
4357
6642
|
*/
|
|
4358
6643
|
200: {
|
|
@@ -4363,9 +6648,15 @@ export type FsListV1ComputerMachineIdFsListGetResponse = FsListV1ComputerMachine
|
|
|
4363
6648
|
export type FsReadV1ComputerMachineIdFsReadGetData = {
|
|
4364
6649
|
body?: never;
|
|
4365
6650
|
path: {
|
|
6651
|
+
/**
|
|
6652
|
+
* Machine Id
|
|
6653
|
+
*/
|
|
4366
6654
|
machine_id: string;
|
|
4367
6655
|
};
|
|
4368
6656
|
query: {
|
|
6657
|
+
/**
|
|
6658
|
+
* Path
|
|
6659
|
+
*/
|
|
4369
6660
|
path: string;
|
|
4370
6661
|
};
|
|
4371
6662
|
url: '/v1/computer/{machine_id}/fs/read';
|
|
@@ -4379,6 +6670,8 @@ export type FsReadV1ComputerMachineIdFsReadGetErrors = {
|
|
|
4379
6670
|
export type FsReadV1ComputerMachineIdFsReadGetError = FsReadV1ComputerMachineIdFsReadGetErrors[keyof FsReadV1ComputerMachineIdFsReadGetErrors];
|
|
4380
6671
|
export type FsReadV1ComputerMachineIdFsReadGetResponses = {
|
|
4381
6672
|
/**
|
|
6673
|
+
* Response Fs Read V1 Computer Machine Id Fs Read Get
|
|
6674
|
+
*
|
|
4382
6675
|
* Successful Response
|
|
4383
6676
|
*/
|
|
4384
6677
|
200: {
|
|
@@ -4395,6 +6688,9 @@ export type FsWriteV1ComputerMachineIdFsWritePostData = {
|
|
|
4395
6688
|
'Idempotency-Key'?: string;
|
|
4396
6689
|
};
|
|
4397
6690
|
path: {
|
|
6691
|
+
/**
|
|
6692
|
+
* Machine Id
|
|
6693
|
+
*/
|
|
4398
6694
|
machine_id: string;
|
|
4399
6695
|
};
|
|
4400
6696
|
query?: never;
|
|
@@ -4409,6 +6705,8 @@ export type FsWriteV1ComputerMachineIdFsWritePostErrors = {
|
|
|
4409
6705
|
export type FsWriteV1ComputerMachineIdFsWritePostError = FsWriteV1ComputerMachineIdFsWritePostErrors[keyof FsWriteV1ComputerMachineIdFsWritePostErrors];
|
|
4410
6706
|
export type FsWriteV1ComputerMachineIdFsWritePostResponses = {
|
|
4411
6707
|
/**
|
|
6708
|
+
* Response Fs Write V1 Computer Machine Id Fs Write Post
|
|
6709
|
+
*
|
|
4412
6710
|
* Successful Response
|
|
4413
6711
|
*/
|
|
4414
6712
|
200: {
|
|
@@ -4425,6 +6723,9 @@ export type PowershellExecV1ComputerMachineIdShellPowershellExecPostData = {
|
|
|
4425
6723
|
'Idempotency-Key'?: string;
|
|
4426
6724
|
};
|
|
4427
6725
|
path: {
|
|
6726
|
+
/**
|
|
6727
|
+
* Machine Id
|
|
6728
|
+
*/
|
|
4428
6729
|
machine_id: string;
|
|
4429
6730
|
};
|
|
4430
6731
|
query?: never;
|
|
@@ -4439,6 +6740,8 @@ export type PowershellExecV1ComputerMachineIdShellPowershellExecPostErrors = {
|
|
|
4439
6740
|
export type PowershellExecV1ComputerMachineIdShellPowershellExecPostError = PowershellExecV1ComputerMachineIdShellPowershellExecPostErrors[keyof PowershellExecV1ComputerMachineIdShellPowershellExecPostErrors];
|
|
4440
6741
|
export type PowershellExecV1ComputerMachineIdShellPowershellExecPostResponses = {
|
|
4441
6742
|
/**
|
|
6743
|
+
* Response Powershell Exec V1 Computer Machine Id Shell Powershell Exec Post
|
|
6744
|
+
*
|
|
4442
6745
|
* Successful Response
|
|
4443
6746
|
*/
|
|
4444
6747
|
200: {
|
|
@@ -4455,6 +6758,9 @@ export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostData =
|
|
|
4455
6758
|
'Idempotency-Key'?: string;
|
|
4456
6759
|
};
|
|
4457
6760
|
path: {
|
|
6761
|
+
/**
|
|
6762
|
+
* Machine Id
|
|
6763
|
+
*/
|
|
4458
6764
|
machine_id: string;
|
|
4459
6765
|
};
|
|
4460
6766
|
query?: never;
|
|
@@ -4469,6 +6775,8 @@ export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostErrors
|
|
|
4469
6775
|
export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostError = PowershellSessionV1ComputerMachineIdShellPowershellSessionPostErrors[keyof PowershellSessionV1ComputerMachineIdShellPowershellSessionPostErrors];
|
|
4470
6776
|
export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostResponses = {
|
|
4471
6777
|
/**
|
|
6778
|
+
* Response Powershell Session V1 Computer Machine Id Shell Powershell Session Post
|
|
6779
|
+
*
|
|
4472
6780
|
* Successful Response
|
|
4473
6781
|
*/
|
|
4474
6782
|
200: {
|
|
@@ -4477,6 +6785,9 @@ export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostRespon
|
|
|
4477
6785
|
};
|
|
4478
6786
|
export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostResponse = PowershellSessionV1ComputerMachineIdShellPowershellSessionPostResponses[keyof PowershellSessionV1ComputerMachineIdShellPowershellSessionPostResponses];
|
|
4479
6787
|
export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostData = {
|
|
6788
|
+
/**
|
|
6789
|
+
* Request
|
|
6790
|
+
*/
|
|
4480
6791
|
body?: CyberdriverShutdownRequest | null;
|
|
4481
6792
|
headers?: {
|
|
4482
6793
|
/**
|
|
@@ -4485,6 +6796,9 @@ export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostData =
|
|
|
4485
6796
|
'Idempotency-Key'?: string;
|
|
4486
6797
|
};
|
|
4487
6798
|
path: {
|
|
6799
|
+
/**
|
|
6800
|
+
* Machine Id
|
|
6801
|
+
*/
|
|
4488
6802
|
machine_id: string;
|
|
4489
6803
|
};
|
|
4490
6804
|
query?: never;
|
|
@@ -4503,6 +6817,8 @@ export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostErrors
|
|
|
4503
6817
|
export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostError = CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostErrors[keyof CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostErrors];
|
|
4504
6818
|
export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostResponses = {
|
|
4505
6819
|
/**
|
|
6820
|
+
* Response Cyberdriver Shutdown V1 Machines Machine Id Cyberdriver Shutdown Post
|
|
6821
|
+
*
|
|
4506
6822
|
* Shutdown was accepted by CyberDriver
|
|
4507
6823
|
*/
|
|
4508
6824
|
200: {
|
|
@@ -4515,10 +6831,14 @@ export type GetUsageAggregateV1UsageAggregateGetData = {
|
|
|
4515
6831
|
path?: never;
|
|
4516
6832
|
query: {
|
|
4517
6833
|
/**
|
|
6834
|
+
* From Date
|
|
6835
|
+
*
|
|
4518
6836
|
* Start of period (inclusive, ISO format)
|
|
4519
6837
|
*/
|
|
4520
6838
|
from_date: string;
|
|
4521
6839
|
/**
|
|
6840
|
+
* To Date
|
|
6841
|
+
*
|
|
4522
6842
|
* End of period (exclusive, ISO format)
|
|
4523
6843
|
*/
|
|
4524
6844
|
to_date: string;
|
|
@@ -4623,6 +6943,10 @@ export type HealthMachinesV1HealthMachinesGetResponses = {
|
|
|
4623
6943
|
200: MachinesHealthCheckResponse;
|
|
4624
6944
|
};
|
|
4625
6945
|
export type HealthMachinesV1HealthMachinesGetResponse = HealthMachinesV1HealthMachinesGetResponses[keyof HealthMachinesV1HealthMachinesGetResponses];
|
|
4626
|
-
export type
|
|
4627
|
-
|
|
6946
|
+
export type RunCompleteWebhookrunCompletePostWebhookPayload = RunCompletedEvent;
|
|
6947
|
+
export type RunCompleteWebhookrunCompletePostWebhookRequest = {
|
|
6948
|
+
body: RunCompleteWebhookrunCompletePostWebhookPayload;
|
|
6949
|
+
key: 'run_complete';
|
|
6950
|
+
path?: never;
|
|
6951
|
+
query?: never;
|
|
4628
6952
|
};
|