@devicecloud.dev/dcd 4.1.4 → 4.1.6
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/commands/cloud.d.ts +30 -0
- package/dist/commands/cloud.js +78 -44
- package/dist/commands/status.d.ts +0 -1
- package/dist/commands/status.js +10 -33
- package/dist/commands/upload.d.ts +1 -0
- package/dist/commands/upload.js +11 -9
- package/dist/config/flags/execution.flags.js +2 -2
- package/dist/gateways/api-gateway.d.ts +2 -2
- package/dist/gateways/supabase-gateway.d.ts +1 -1
- package/dist/gateways/supabase-gateway.js +51 -9
- package/dist/methods.d.ts +1 -1
- package/dist/methods.js +183 -25
- package/dist/services/execution-plan.service.d.ts +23 -0
- package/dist/services/execution-plan.service.js +41 -0
- package/dist/services/results-polling.service.d.ts +30 -0
- package/dist/services/results-polling.service.js +167 -71
- package/dist/services/test-submission.service.js +11 -0
- package/dist/types/generated/schema.types.d.ts +1086 -348
- package/dist/types/schema.types.d.ts +1523 -0
- package/dist/types/schema.types.js +3 -0
- package/dist/utils/styling.d.ts +106 -0
- package/dist/utils/styling.js +166 -0
- package/oclif.manifest.json +10 -3
- package/package.json +16 -15
|
@@ -3,101 +3,446 @@
|
|
|
3
3
|
* Do not make direct changes to the file.
|
|
4
4
|
*/
|
|
5
5
|
export interface paths {
|
|
6
|
-
"/
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
6
|
+
"/uploads/binary": {
|
|
7
|
+
parameters: {
|
|
8
|
+
query?: never;
|
|
9
|
+
header?: never;
|
|
10
|
+
path?: never;
|
|
11
|
+
cookie?: never;
|
|
12
|
+
};
|
|
13
|
+
get?: never;
|
|
14
|
+
put?: never;
|
|
15
|
+
post: operations["UploadsController_createBinary"];
|
|
16
|
+
delete?: never;
|
|
17
|
+
options?: never;
|
|
18
|
+
head?: never;
|
|
19
|
+
patch?: never;
|
|
20
|
+
trace?: never;
|
|
12
21
|
};
|
|
13
|
-
"/
|
|
14
|
-
|
|
22
|
+
"/uploads/getBinaryUploadUrl": {
|
|
23
|
+
parameters: {
|
|
24
|
+
query?: never;
|
|
25
|
+
header?: never;
|
|
26
|
+
path?: never;
|
|
27
|
+
cookie?: never;
|
|
28
|
+
};
|
|
29
|
+
get?: never;
|
|
30
|
+
put?: never;
|
|
31
|
+
post: operations["UploadsController_getBinaryUploadUrl"];
|
|
32
|
+
delete?: never;
|
|
33
|
+
options?: never;
|
|
34
|
+
head?: never;
|
|
35
|
+
patch?: never;
|
|
36
|
+
trace?: never;
|
|
15
37
|
};
|
|
16
|
-
"/
|
|
17
|
-
|
|
38
|
+
"/uploads/checkForExistingUpload": {
|
|
39
|
+
parameters: {
|
|
40
|
+
query?: never;
|
|
41
|
+
header?: never;
|
|
42
|
+
path?: never;
|
|
43
|
+
cookie?: never;
|
|
44
|
+
};
|
|
45
|
+
get?: never;
|
|
46
|
+
put?: never;
|
|
47
|
+
post: operations["UploadsController_checkForExistingUpload"];
|
|
48
|
+
delete?: never;
|
|
49
|
+
options?: never;
|
|
50
|
+
head?: never;
|
|
51
|
+
patch?: never;
|
|
52
|
+
trace?: never;
|
|
18
53
|
};
|
|
19
|
-
"/
|
|
20
|
-
|
|
54
|
+
"/uploads/finaliseUpload": {
|
|
55
|
+
parameters: {
|
|
56
|
+
query?: never;
|
|
57
|
+
header?: never;
|
|
58
|
+
path?: never;
|
|
59
|
+
cookie?: never;
|
|
60
|
+
};
|
|
61
|
+
get?: never;
|
|
62
|
+
put?: never;
|
|
63
|
+
post: operations["UploadsController_finaliseUpload"];
|
|
64
|
+
delete?: never;
|
|
65
|
+
options?: never;
|
|
66
|
+
head?: never;
|
|
67
|
+
patch?: never;
|
|
68
|
+
trace?: never;
|
|
21
69
|
};
|
|
22
|
-
"/
|
|
23
|
-
|
|
70
|
+
"/uploads/flow": {
|
|
71
|
+
parameters: {
|
|
72
|
+
query?: never;
|
|
73
|
+
header?: never;
|
|
74
|
+
path?: never;
|
|
75
|
+
cookie?: never;
|
|
76
|
+
};
|
|
77
|
+
get?: never;
|
|
78
|
+
put?: never;
|
|
79
|
+
post: operations["UploadsController_createTest"];
|
|
80
|
+
delete?: never;
|
|
81
|
+
options?: never;
|
|
82
|
+
head?: never;
|
|
83
|
+
patch?: never;
|
|
84
|
+
trace?: never;
|
|
24
85
|
};
|
|
25
|
-
"/
|
|
26
|
-
|
|
86
|
+
"/uploads/retryTest": {
|
|
87
|
+
parameters: {
|
|
88
|
+
query?: never;
|
|
89
|
+
header?: never;
|
|
90
|
+
path?: never;
|
|
91
|
+
cookie?: never;
|
|
92
|
+
};
|
|
93
|
+
get?: never;
|
|
94
|
+
put?: never;
|
|
95
|
+
post: operations["UploadsController_retryTest"];
|
|
96
|
+
delete?: never;
|
|
97
|
+
options?: never;
|
|
98
|
+
head?: never;
|
|
99
|
+
patch?: never;
|
|
100
|
+
trace?: never;
|
|
27
101
|
};
|
|
28
|
-
"/
|
|
29
|
-
|
|
102
|
+
"/uploads/cancelTest": {
|
|
103
|
+
parameters: {
|
|
104
|
+
query?: never;
|
|
105
|
+
header?: never;
|
|
106
|
+
path?: never;
|
|
107
|
+
cookie?: never;
|
|
108
|
+
};
|
|
109
|
+
get?: never;
|
|
110
|
+
put?: never;
|
|
111
|
+
post: operations["UploadsController_cancelTest"];
|
|
112
|
+
delete?: never;
|
|
113
|
+
options?: never;
|
|
114
|
+
head?: never;
|
|
115
|
+
patch?: never;
|
|
116
|
+
trace?: never;
|
|
117
|
+
};
|
|
118
|
+
"/uploads/status": {
|
|
119
|
+
parameters: {
|
|
120
|
+
query?: never;
|
|
121
|
+
header?: never;
|
|
122
|
+
path?: never;
|
|
123
|
+
cookie?: never;
|
|
124
|
+
};
|
|
125
|
+
get: operations["UploadsController_getUploadStatus"];
|
|
126
|
+
put?: never;
|
|
127
|
+
post?: never;
|
|
128
|
+
delete?: never;
|
|
129
|
+
options?: never;
|
|
130
|
+
head?: never;
|
|
131
|
+
patch?: never;
|
|
132
|
+
trace?: never;
|
|
133
|
+
};
|
|
134
|
+
"/uploads/{uploadId}": {
|
|
135
|
+
parameters: {
|
|
136
|
+
query?: never;
|
|
137
|
+
header?: never;
|
|
138
|
+
path?: never;
|
|
139
|
+
cookie?: never;
|
|
140
|
+
};
|
|
141
|
+
get?: never;
|
|
142
|
+
put?: never;
|
|
143
|
+
post?: never;
|
|
144
|
+
delete: operations["UploadsController_deleteUpload"];
|
|
145
|
+
options?: never;
|
|
146
|
+
head?: never;
|
|
147
|
+
patch?: never;
|
|
148
|
+
trace?: never;
|
|
30
149
|
};
|
|
31
150
|
"/results/{uploadId}": {
|
|
151
|
+
parameters: {
|
|
152
|
+
query?: never;
|
|
153
|
+
header?: never;
|
|
154
|
+
path?: never;
|
|
155
|
+
cookie?: never;
|
|
156
|
+
};
|
|
32
157
|
get: operations["ResultsController_getResults"];
|
|
158
|
+
put?: never;
|
|
159
|
+
post?: never;
|
|
160
|
+
delete?: never;
|
|
161
|
+
options?: never;
|
|
162
|
+
head?: never;
|
|
163
|
+
patch?: never;
|
|
164
|
+
trace?: never;
|
|
33
165
|
};
|
|
34
166
|
"/results/{uploadId}/download": {
|
|
167
|
+
parameters: {
|
|
168
|
+
query?: never;
|
|
169
|
+
header?: never;
|
|
170
|
+
path?: never;
|
|
171
|
+
cookie?: never;
|
|
172
|
+
};
|
|
173
|
+
get?: never;
|
|
174
|
+
put?: never;
|
|
35
175
|
post: operations["ResultsController_getTestRunArtifacts"];
|
|
176
|
+
delete?: never;
|
|
177
|
+
options?: never;
|
|
178
|
+
head?: never;
|
|
179
|
+
patch?: never;
|
|
180
|
+
trace?: never;
|
|
36
181
|
};
|
|
37
|
-
"/results/{uploadId}
|
|
38
|
-
|
|
182
|
+
"/results/notify/{uploadId}": {
|
|
183
|
+
parameters: {
|
|
184
|
+
query?: never;
|
|
185
|
+
header?: never;
|
|
186
|
+
path?: never;
|
|
187
|
+
cookie?: never;
|
|
188
|
+
};
|
|
189
|
+
get?: never;
|
|
190
|
+
put?: never;
|
|
191
|
+
post: operations["ResultsController_notifyTestRunComplete"];
|
|
192
|
+
delete?: never;
|
|
193
|
+
options?: never;
|
|
194
|
+
head?: never;
|
|
195
|
+
patch?: never;
|
|
196
|
+
trace?: never;
|
|
39
197
|
};
|
|
40
198
|
"/results/{uploadId}/report": {
|
|
199
|
+
parameters: {
|
|
200
|
+
query?: never;
|
|
201
|
+
header?: never;
|
|
202
|
+
path?: never;
|
|
203
|
+
cookie?: never;
|
|
204
|
+
};
|
|
41
205
|
get: operations["ResultsController_downloadReport"];
|
|
206
|
+
put?: never;
|
|
207
|
+
post?: never;
|
|
208
|
+
delete?: never;
|
|
209
|
+
options?: never;
|
|
210
|
+
head?: never;
|
|
211
|
+
patch?: never;
|
|
212
|
+
trace?: never;
|
|
213
|
+
};
|
|
214
|
+
"/results/{uploadId}/html-report": {
|
|
215
|
+
parameters: {
|
|
216
|
+
query?: never;
|
|
217
|
+
header?: never;
|
|
218
|
+
path?: never;
|
|
219
|
+
cookie?: never;
|
|
220
|
+
};
|
|
221
|
+
get: operations["ResultsController_downloadHtmlReport"];
|
|
222
|
+
put?: never;
|
|
223
|
+
post?: never;
|
|
224
|
+
delete?: never;
|
|
225
|
+
options?: never;
|
|
226
|
+
head?: never;
|
|
227
|
+
patch?: never;
|
|
228
|
+
trace?: never;
|
|
42
229
|
};
|
|
43
230
|
"/results/compatibility/data": {
|
|
231
|
+
parameters: {
|
|
232
|
+
query?: never;
|
|
233
|
+
header?: never;
|
|
234
|
+
path?: never;
|
|
235
|
+
cookie?: never;
|
|
236
|
+
};
|
|
44
237
|
get: operations["ResultsController_getCompatibilityData"];
|
|
238
|
+
put?: never;
|
|
239
|
+
post?: never;
|
|
240
|
+
delete?: never;
|
|
241
|
+
options?: never;
|
|
242
|
+
head?: never;
|
|
243
|
+
patch?: never;
|
|
244
|
+
trace?: never;
|
|
45
245
|
};
|
|
46
|
-
"/
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
post
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
post: operations["UploadsController_createTest"];
|
|
66
|
-
};
|
|
67
|
-
"/uploads/getBinaryUploadUrl": {
|
|
68
|
-
post: operations["UploadsController_getBinaryUploadUrl"];
|
|
69
|
-
};
|
|
70
|
-
"/uploads/retryTest": {
|
|
71
|
-
post: operations["UploadsController_retryTest"];
|
|
72
|
-
};
|
|
73
|
-
"/uploads/status": {
|
|
74
|
-
get: operations["UploadsController_getUploadStatus"];
|
|
246
|
+
"/allure/{uploadId}/download": {
|
|
247
|
+
parameters: {
|
|
248
|
+
query?: never;
|
|
249
|
+
header?: never;
|
|
250
|
+
path?: never;
|
|
251
|
+
cookie?: never;
|
|
252
|
+
};
|
|
253
|
+
/**
|
|
254
|
+
* Download Allure report as HTML
|
|
255
|
+
* @description Downloads a single-file Allure report as HTML containing all test results. Report is generated once and stored in Supabase Storage for subsequent downloads.
|
|
256
|
+
*/
|
|
257
|
+
get: operations["AllureController_downloadAllureReport"];
|
|
258
|
+
put?: never;
|
|
259
|
+
post?: never;
|
|
260
|
+
delete?: never;
|
|
261
|
+
options?: never;
|
|
262
|
+
head?: never;
|
|
263
|
+
patch?: never;
|
|
264
|
+
trace?: never;
|
|
75
265
|
};
|
|
76
266
|
"/webhooks": {
|
|
77
|
-
|
|
267
|
+
parameters: {
|
|
268
|
+
query?: never;
|
|
269
|
+
header?: never;
|
|
270
|
+
path?: never;
|
|
271
|
+
cookie?: never;
|
|
272
|
+
};
|
|
78
273
|
get: operations["WebhooksController_getWebhook"];
|
|
274
|
+
put?: never;
|
|
79
275
|
post: operations["WebhooksController_setWebhook"];
|
|
276
|
+
delete: operations["WebhooksController_deleteWebhook"];
|
|
277
|
+
options?: never;
|
|
278
|
+
head?: never;
|
|
279
|
+
patch?: never;
|
|
280
|
+
trace?: never;
|
|
80
281
|
};
|
|
81
282
|
"/webhooks/regenerate-secret": {
|
|
283
|
+
parameters: {
|
|
284
|
+
query?: never;
|
|
285
|
+
header?: never;
|
|
286
|
+
path?: never;
|
|
287
|
+
cookie?: never;
|
|
288
|
+
};
|
|
289
|
+
get?: never;
|
|
290
|
+
put?: never;
|
|
82
291
|
post: operations["WebhooksController_regenerateWebhookSecret"];
|
|
292
|
+
delete?: never;
|
|
293
|
+
options?: never;
|
|
294
|
+
head?: never;
|
|
295
|
+
patch?: never;
|
|
296
|
+
trace?: never;
|
|
83
297
|
};
|
|
84
298
|
"/webhooks/test": {
|
|
299
|
+
parameters: {
|
|
300
|
+
query?: never;
|
|
301
|
+
header?: never;
|
|
302
|
+
path?: never;
|
|
303
|
+
cookie?: never;
|
|
304
|
+
};
|
|
305
|
+
get?: never;
|
|
306
|
+
put?: never;
|
|
85
307
|
post: operations["WebhooksController_testWebhook"];
|
|
308
|
+
delete?: never;
|
|
309
|
+
options?: never;
|
|
310
|
+
head?: never;
|
|
311
|
+
patch?: never;
|
|
312
|
+
trace?: never;
|
|
313
|
+
};
|
|
314
|
+
"/org/increase_credits": {
|
|
315
|
+
parameters: {
|
|
316
|
+
query?: never;
|
|
317
|
+
header?: never;
|
|
318
|
+
path?: never;
|
|
319
|
+
cookie?: never;
|
|
320
|
+
};
|
|
321
|
+
get?: never;
|
|
322
|
+
put?: never;
|
|
323
|
+
post: operations["OrgController_paddleTransactionCompleted"];
|
|
324
|
+
delete?: never;
|
|
325
|
+
options?: never;
|
|
326
|
+
head?: never;
|
|
327
|
+
patch?: never;
|
|
328
|
+
trace?: never;
|
|
329
|
+
};
|
|
330
|
+
"/org/update-name": {
|
|
331
|
+
parameters: {
|
|
332
|
+
query?: never;
|
|
333
|
+
header?: never;
|
|
334
|
+
path?: never;
|
|
335
|
+
cookie?: never;
|
|
336
|
+
};
|
|
337
|
+
get?: never;
|
|
338
|
+
put?: never;
|
|
339
|
+
post: operations["OrgController_updateOrgName"];
|
|
340
|
+
delete?: never;
|
|
341
|
+
options?: never;
|
|
342
|
+
head?: never;
|
|
343
|
+
patch?: never;
|
|
344
|
+
trace?: never;
|
|
345
|
+
};
|
|
346
|
+
"/org/invite-team-member": {
|
|
347
|
+
parameters: {
|
|
348
|
+
query?: never;
|
|
349
|
+
header?: never;
|
|
350
|
+
path?: never;
|
|
351
|
+
cookie?: never;
|
|
352
|
+
};
|
|
353
|
+
get?: never;
|
|
354
|
+
put?: never;
|
|
355
|
+
post: operations["OrgController_inviteTeamMember"];
|
|
356
|
+
delete?: never;
|
|
357
|
+
options?: never;
|
|
358
|
+
head?: never;
|
|
359
|
+
patch?: never;
|
|
360
|
+
trace?: never;
|
|
361
|
+
};
|
|
362
|
+
"/org/accept-invite": {
|
|
363
|
+
parameters: {
|
|
364
|
+
query?: never;
|
|
365
|
+
header?: never;
|
|
366
|
+
path?: never;
|
|
367
|
+
cookie?: never;
|
|
368
|
+
};
|
|
369
|
+
get?: never;
|
|
370
|
+
put?: never;
|
|
371
|
+
post: operations["OrgController_acceptInvite"];
|
|
372
|
+
delete?: never;
|
|
373
|
+
options?: never;
|
|
374
|
+
head?: never;
|
|
375
|
+
patch?: never;
|
|
376
|
+
trace?: never;
|
|
377
|
+
};
|
|
378
|
+
"/frontend/check-domain-saml": {
|
|
379
|
+
parameters: {
|
|
380
|
+
query?: never;
|
|
381
|
+
header?: never;
|
|
382
|
+
path?: never;
|
|
383
|
+
cookie?: never;
|
|
384
|
+
};
|
|
385
|
+
get?: never;
|
|
386
|
+
put?: never;
|
|
387
|
+
post: operations["FrontendController_checkDomainSaml"];
|
|
388
|
+
delete?: never;
|
|
389
|
+
options?: never;
|
|
390
|
+
head?: never;
|
|
391
|
+
patch?: never;
|
|
392
|
+
trace?: never;
|
|
393
|
+
};
|
|
394
|
+
"/health": {
|
|
395
|
+
parameters: {
|
|
396
|
+
query?: never;
|
|
397
|
+
header?: never;
|
|
398
|
+
path?: never;
|
|
399
|
+
cookie?: never;
|
|
400
|
+
};
|
|
401
|
+
get: operations["HealthController_health"];
|
|
402
|
+
put?: never;
|
|
403
|
+
post?: never;
|
|
404
|
+
delete?: never;
|
|
405
|
+
options?: never;
|
|
406
|
+
head?: never;
|
|
407
|
+
patch?: never;
|
|
408
|
+
trace?: never;
|
|
86
409
|
};
|
|
87
410
|
}
|
|
88
411
|
export type webhooks = Record<string, never>;
|
|
89
412
|
export interface components {
|
|
90
|
-
headers: never;
|
|
91
|
-
parameters: never;
|
|
92
|
-
pathItems: never;
|
|
93
|
-
requestBodies: never;
|
|
94
|
-
responses: never;
|
|
95
413
|
schemas: {
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
414
|
+
IDBResult: {
|
|
415
|
+
binary_upload_id: string;
|
|
416
|
+
cost: number | null;
|
|
417
|
+
created_at: string;
|
|
418
|
+
env: Record<string, never>;
|
|
419
|
+
id: number;
|
|
420
|
+
org_id: number;
|
|
421
|
+
platform: string;
|
|
422
|
+
simulator_name: string;
|
|
423
|
+
status: string;
|
|
424
|
+
test_file_name: string;
|
|
425
|
+
test_upload_id: string;
|
|
426
|
+
};
|
|
427
|
+
ICreateBinaryUploadArgs: {
|
|
428
|
+
/**
|
|
429
|
+
* Format: binary
|
|
430
|
+
* @description This file must either be an apk or a zip file
|
|
431
|
+
*/
|
|
432
|
+
file: string;
|
|
433
|
+
};
|
|
434
|
+
ICreateBinaryResponse: {
|
|
435
|
+
message: string;
|
|
436
|
+
binaryId: string;
|
|
437
|
+
};
|
|
438
|
+
IGetBinaryUploadUrlArgs: {
|
|
439
|
+
platform: Record<string, never>;
|
|
440
|
+
};
|
|
441
|
+
IGetBinaryUploadUrlResponse: {
|
|
442
|
+
message: string;
|
|
443
|
+
path: string;
|
|
444
|
+
token: string;
|
|
445
|
+
id: string;
|
|
101
446
|
};
|
|
102
447
|
ICheckForExistingUploadArgs: {
|
|
103
448
|
sha: string;
|
|
@@ -106,305 +451,343 @@ export interface components {
|
|
|
106
451
|
appBinaryId: string;
|
|
107
452
|
exists: boolean;
|
|
108
453
|
};
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
454
|
+
IFinaliseUploadArgs: {
|
|
455
|
+
id: string;
|
|
456
|
+
path: string;
|
|
457
|
+
metadata: Record<string, never>;
|
|
458
|
+
sha: string;
|
|
112
459
|
};
|
|
113
|
-
|
|
460
|
+
IFinaliseUploadResponse: Record<string, never>;
|
|
461
|
+
ICreateTestUploadArgs: {
|
|
114
462
|
/**
|
|
115
463
|
* Format: binary
|
|
116
|
-
* @description This file must
|
|
464
|
+
* @description This file must be a zip file
|
|
117
465
|
*/
|
|
118
466
|
file: string;
|
|
119
|
-
};
|
|
120
|
-
ICreateTestUploadArgs: {
|
|
121
467
|
/** @enum {string} */
|
|
122
468
|
androidApiLevel?: "29" | "30" | "31" | "32" | "33" | "34" | "35";
|
|
123
469
|
/** @enum {string} */
|
|
124
|
-
androidDevice?: "
|
|
470
|
+
androidDevice?: "pixel-6" | "pixel-6-pro" | "pixel-7" | "pixel-7-pro" | "generic-tablet";
|
|
125
471
|
apiKey?: string;
|
|
126
472
|
apiUrl?: string;
|
|
127
|
-
appBinaryId: string;
|
|
128
473
|
appFile?: string;
|
|
129
|
-
config: string;
|
|
130
|
-
env: string;
|
|
131
|
-
/**
|
|
132
|
-
* Format: binary
|
|
133
|
-
* @description This file must be a zip file
|
|
134
|
-
*/
|
|
135
|
-
file: string;
|
|
136
|
-
flowMetadata?: string;
|
|
137
|
-
googlePlay: boolean;
|
|
138
|
-
/** @enum {string} */
|
|
139
|
-
iOSDevice?: "ipad-pro-6th-gen" | "iphone-14" | "iphone-14-pro" | "iphone-15" | "iphone-15-pro" | "iphone-16" | "iphone-16-plus" | "iphone-16-pro" | "iphone-16-pro-max";
|
|
140
474
|
/** @enum {string} */
|
|
141
475
|
iOSVersion?: "16" | "17" | "18" | "26";
|
|
142
|
-
|
|
143
|
-
|
|
476
|
+
/** @enum {string} */
|
|
477
|
+
iOSDevice?: "iphone-14" | "iphone-14-pro" | "iphone-15" | "iphone-15-pro" | "iphone-16" | "iphone-16-plus" | "iphone-16-pro" | "iphone-16-pro-max" | "ipad-pro-6th-gen";
|
|
144
478
|
platform?: string;
|
|
145
479
|
/** @enum {string} */
|
|
146
|
-
runnerType?: "
|
|
147
|
-
|
|
148
|
-
testFileNames?: string;
|
|
149
|
-
testFileOverrides?: string;
|
|
480
|
+
runnerType?: "m4" | "m1" | "default" | "gpu1" | "cpu1";
|
|
481
|
+
metadata?: string;
|
|
150
482
|
workspaceConfig?: string;
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
env:
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
simulator_name: string;
|
|
161
|
-
status: string;
|
|
162
|
-
test_file_name: string;
|
|
163
|
-
test_upload_id: string;
|
|
164
|
-
};
|
|
165
|
-
IFinaliseUploadArgs: {
|
|
166
|
-
id: string;
|
|
167
|
-
metadata: Record<string, never>;
|
|
168
|
-
path: string;
|
|
169
|
-
sha: string;
|
|
170
|
-
};
|
|
171
|
-
IFinaliseUploadResponse: Record<string, never>;
|
|
172
|
-
IGetBinaryUploadUrlArgs: {
|
|
173
|
-
platform: Record<string, never>;
|
|
174
|
-
};
|
|
175
|
-
IGetBinaryUploadUrlResponse: {
|
|
176
|
-
id: string;
|
|
177
|
-
message: string;
|
|
178
|
-
path: string;
|
|
179
|
-
token: string;
|
|
483
|
+
flowMetadata?: string;
|
|
484
|
+
testFileOverrides?: string;
|
|
485
|
+
testFileNames?: string;
|
|
486
|
+
sequentialFlows?: string;
|
|
487
|
+
appBinaryId: string;
|
|
488
|
+
env: string;
|
|
489
|
+
googlePlay: boolean;
|
|
490
|
+
config: string;
|
|
491
|
+
name: string;
|
|
180
492
|
};
|
|
181
493
|
IRetryTestArgs: {
|
|
182
494
|
resultId: number;
|
|
183
495
|
};
|
|
496
|
+
ICancelTestArgs: {
|
|
497
|
+
/** @description ID of a specific result to cancel. Either resultId or uploadId must be provided, but not both. */
|
|
498
|
+
resultId?: number;
|
|
499
|
+
/** @description ID of an upload to cancel all pending results for. Either resultId or uploadId must be provided, but not both. */
|
|
500
|
+
uploadId?: string;
|
|
501
|
+
};
|
|
184
502
|
TResultResponse: {
|
|
185
|
-
duration_seconds?: number;
|
|
186
|
-
fail_reason?: string;
|
|
187
503
|
id: number;
|
|
188
|
-
retry_of?: number;
|
|
189
|
-
status: string;
|
|
190
504
|
test_file_name: string;
|
|
505
|
+
status: string;
|
|
506
|
+
retry_of?: number;
|
|
507
|
+
fail_reason?: string;
|
|
508
|
+
duration_seconds?: number;
|
|
191
509
|
};
|
|
192
510
|
};
|
|
511
|
+
responses: never;
|
|
512
|
+
parameters: never;
|
|
513
|
+
requestBodies: never;
|
|
514
|
+
headers: never;
|
|
515
|
+
pathItems: never;
|
|
193
516
|
}
|
|
194
517
|
export type $defs = Record<string, never>;
|
|
195
|
-
export type external = Record<string, never>;
|
|
196
518
|
export interface operations {
|
|
197
|
-
|
|
198
|
-
* Download Allure report as HTML
|
|
199
|
-
* @description Downloads a single-file Allure report as HTML containing all test results. Report is generated once and stored in Supabase Storage for subsequent downloads.
|
|
200
|
-
*/
|
|
201
|
-
AllureController_downloadAllureReport: {
|
|
519
|
+
UploadsController_createBinary: {
|
|
202
520
|
parameters: {
|
|
521
|
+
query?: never;
|
|
203
522
|
header: {
|
|
204
523
|
"x-app-api-key": string;
|
|
205
524
|
};
|
|
206
|
-
path
|
|
207
|
-
|
|
208
|
-
|
|
525
|
+
path?: never;
|
|
526
|
+
cookie?: never;
|
|
527
|
+
};
|
|
528
|
+
requestBody: {
|
|
529
|
+
content: {
|
|
530
|
+
"multipart/form-data": components["schemas"]["ICreateBinaryUploadArgs"];
|
|
209
531
|
};
|
|
210
532
|
};
|
|
211
533
|
responses: {
|
|
212
|
-
/**
|
|
213
|
-
|
|
534
|
+
/**
|
|
535
|
+
* @description The record has been successfully created.
|
|
536
|
+
* @example {
|
|
537
|
+
* "message": "Binary uploaded successfully",
|
|
538
|
+
* "binaryId": "binary-123-abc-def"
|
|
539
|
+
* }
|
|
540
|
+
*/
|
|
541
|
+
201: {
|
|
542
|
+
headers: {
|
|
543
|
+
[name: string]: unknown;
|
|
544
|
+
};
|
|
214
545
|
content: {
|
|
215
|
-
|
|
546
|
+
/**
|
|
547
|
+
* @example {
|
|
548
|
+
* "message": "Binary uploaded successfully",
|
|
549
|
+
* "binaryId": "binary-123-abc-def"
|
|
550
|
+
* }
|
|
551
|
+
*/
|
|
552
|
+
"application/json": components["schemas"]["ICreateBinaryResponse"];
|
|
216
553
|
};
|
|
217
554
|
};
|
|
218
|
-
/** @description Upload not found or no results available */
|
|
219
|
-
404: {
|
|
220
|
-
content: never;
|
|
221
|
-
};
|
|
222
555
|
};
|
|
223
556
|
};
|
|
224
|
-
|
|
225
|
-
|
|
557
|
+
UploadsController_getBinaryUploadUrl: {
|
|
558
|
+
parameters: {
|
|
559
|
+
query?: never;
|
|
560
|
+
header: {
|
|
561
|
+
"x-app-api-key": string;
|
|
562
|
+
};
|
|
563
|
+
path?: never;
|
|
564
|
+
cookie?: never;
|
|
565
|
+
};
|
|
226
566
|
requestBody: {
|
|
227
567
|
content: {
|
|
228
|
-
"application/json":
|
|
229
|
-
/** @example example.com */
|
|
230
|
-
domain: string;
|
|
231
|
-
};
|
|
568
|
+
"application/json": components["schemas"]["IGetBinaryUploadUrlArgs"];
|
|
232
569
|
};
|
|
233
570
|
};
|
|
234
571
|
responses: {
|
|
235
|
-
/** @description
|
|
236
|
-
200: {
|
|
237
|
-
content: {
|
|
238
|
-
"application/json": {
|
|
239
|
-
forceSaml?: boolean;
|
|
240
|
-
};
|
|
241
|
-
};
|
|
242
|
-
};
|
|
572
|
+
/** @description The url has been successfully created. */
|
|
243
573
|
201: {
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
/** @description Bad request - invalid domain or API error */
|
|
247
|
-
400: {
|
|
248
|
-
content: {
|
|
249
|
-
"application/json": {
|
|
250
|
-
error?: string;
|
|
251
|
-
};
|
|
574
|
+
headers: {
|
|
575
|
+
[name: string]: unknown;
|
|
252
576
|
};
|
|
253
|
-
};
|
|
254
|
-
};
|
|
255
|
-
};
|
|
256
|
-
HealthController_health: {
|
|
257
|
-
responses: {
|
|
258
|
-
/** @description Health check endpoint */
|
|
259
|
-
200: {
|
|
260
577
|
content: {
|
|
261
|
-
"application/json":
|
|
262
|
-
/** @example ok */
|
|
263
|
-
status?: string;
|
|
264
|
-
};
|
|
578
|
+
"application/json": components["schemas"]["IGetBinaryUploadUrlResponse"];
|
|
265
579
|
};
|
|
266
580
|
};
|
|
267
581
|
};
|
|
268
582
|
};
|
|
269
|
-
|
|
583
|
+
UploadsController_checkForExistingUpload: {
|
|
270
584
|
parameters: {
|
|
585
|
+
query?: never;
|
|
271
586
|
header: {
|
|
272
587
|
"x-app-api-key": string;
|
|
273
588
|
};
|
|
589
|
+
path?: never;
|
|
590
|
+
cookie?: never;
|
|
274
591
|
};
|
|
275
592
|
requestBody: {
|
|
276
593
|
content: {
|
|
277
|
-
"application/json":
|
|
278
|
-
orgId: string;
|
|
279
|
-
};
|
|
594
|
+
"application/json": components["schemas"]["ICheckForExistingUploadArgs"];
|
|
280
595
|
};
|
|
281
596
|
};
|
|
282
597
|
responses: {
|
|
283
|
-
/** @description
|
|
598
|
+
/** @description The url has been successfully created. */
|
|
284
599
|
201: {
|
|
600
|
+
headers: {
|
|
601
|
+
[name: string]: unknown;
|
|
602
|
+
};
|
|
285
603
|
content: {
|
|
286
|
-
"application/json":
|
|
604
|
+
"application/json": components["schemas"]["ICheckForExistingUploadResponse"];
|
|
287
605
|
};
|
|
288
606
|
};
|
|
289
607
|
};
|
|
290
608
|
};
|
|
291
|
-
|
|
609
|
+
UploadsController_finaliseUpload: {
|
|
292
610
|
parameters: {
|
|
611
|
+
query?: never;
|
|
293
612
|
header: {
|
|
294
613
|
"x-app-api-key": string;
|
|
295
614
|
};
|
|
615
|
+
path?: never;
|
|
616
|
+
cookie?: never;
|
|
296
617
|
};
|
|
297
618
|
requestBody: {
|
|
298
619
|
content: {
|
|
299
|
-
"application/json":
|
|
300
|
-
inviteEmail: string;
|
|
301
|
-
link: string;
|
|
302
|
-
orgId: string;
|
|
303
|
-
orgName: string;
|
|
304
|
-
requesterEmail: string;
|
|
305
|
-
};
|
|
620
|
+
"application/json": components["schemas"]["IFinaliseUploadArgs"];
|
|
306
621
|
};
|
|
307
622
|
};
|
|
308
623
|
responses: {
|
|
309
|
-
/** @description
|
|
624
|
+
/** @description The upload has been completed. */
|
|
310
625
|
201: {
|
|
626
|
+
headers: {
|
|
627
|
+
[name: string]: unknown;
|
|
628
|
+
};
|
|
311
629
|
content: {
|
|
312
|
-
"application/json":
|
|
630
|
+
"application/json": components["schemas"]["IFinaliseUploadResponse"];
|
|
313
631
|
};
|
|
314
632
|
};
|
|
315
633
|
};
|
|
316
634
|
};
|
|
317
|
-
|
|
635
|
+
UploadsController_createTest: {
|
|
318
636
|
parameters: {
|
|
637
|
+
query?: never;
|
|
319
638
|
header: {
|
|
320
|
-
"
|
|
639
|
+
"x-app-api-key": string;
|
|
640
|
+
};
|
|
641
|
+
path?: never;
|
|
642
|
+
cookie?: never;
|
|
643
|
+
};
|
|
644
|
+
requestBody: {
|
|
645
|
+
content: {
|
|
646
|
+
"multipart/form-data": components["schemas"]["ICreateTestUploadArgs"];
|
|
321
647
|
};
|
|
322
648
|
};
|
|
323
649
|
responses: {
|
|
324
|
-
/** @description
|
|
650
|
+
/** @description The record has been successfully created. */
|
|
325
651
|
201: {
|
|
652
|
+
headers: {
|
|
653
|
+
[name: string]: unknown;
|
|
654
|
+
};
|
|
326
655
|
content: {
|
|
327
|
-
"application/json":
|
|
656
|
+
"application/json": {
|
|
657
|
+
message?: string;
|
|
658
|
+
results?: components["schemas"]["IDBResult"][];
|
|
659
|
+
};
|
|
328
660
|
};
|
|
329
661
|
};
|
|
330
662
|
};
|
|
331
663
|
};
|
|
332
|
-
|
|
664
|
+
UploadsController_retryTest: {
|
|
333
665
|
parameters: {
|
|
666
|
+
query?: never;
|
|
334
667
|
header: {
|
|
335
668
|
"x-app-api-key": string;
|
|
336
669
|
};
|
|
670
|
+
path?: never;
|
|
671
|
+
cookie?: never;
|
|
337
672
|
};
|
|
338
673
|
requestBody: {
|
|
339
674
|
content: {
|
|
340
|
-
"application/json":
|
|
341
|
-
name: string;
|
|
342
|
-
orgId: string;
|
|
343
|
-
};
|
|
675
|
+
"application/json": components["schemas"]["IRetryTestArgs"];
|
|
344
676
|
};
|
|
345
677
|
};
|
|
346
678
|
responses: {
|
|
347
|
-
/** @description
|
|
679
|
+
/** @description The record has been successfully created. */
|
|
348
680
|
201: {
|
|
681
|
+
headers: {
|
|
682
|
+
[name: string]: unknown;
|
|
683
|
+
};
|
|
349
684
|
content: {
|
|
350
|
-
"application/json":
|
|
685
|
+
"application/json": {
|
|
686
|
+
message?: string;
|
|
687
|
+
results?: components["schemas"]["IDBResult"][];
|
|
688
|
+
};
|
|
351
689
|
};
|
|
352
690
|
};
|
|
353
691
|
};
|
|
354
692
|
};
|
|
355
|
-
|
|
693
|
+
UploadsController_cancelTest: {
|
|
356
694
|
parameters: {
|
|
695
|
+
query?: never;
|
|
357
696
|
header: {
|
|
358
697
|
"x-app-api-key": string;
|
|
359
698
|
};
|
|
360
|
-
path
|
|
361
|
-
|
|
699
|
+
path?: never;
|
|
700
|
+
cookie?: never;
|
|
701
|
+
};
|
|
702
|
+
requestBody: {
|
|
703
|
+
content: {
|
|
704
|
+
"application/json": components["schemas"]["ICancelTestArgs"];
|
|
362
705
|
};
|
|
363
706
|
};
|
|
364
707
|
responses: {
|
|
365
|
-
/** @description
|
|
366
|
-
|
|
708
|
+
/** @description The record has been successfully cancelled. */
|
|
709
|
+
201: {
|
|
710
|
+
headers: {
|
|
711
|
+
[name: string]: unknown;
|
|
712
|
+
};
|
|
367
713
|
content: {
|
|
368
|
-
"application/json":
|
|
714
|
+
"application/json": {
|
|
715
|
+
message?: string;
|
|
716
|
+
success?: boolean;
|
|
717
|
+
cancelledCount?: number;
|
|
718
|
+
};
|
|
369
719
|
};
|
|
370
720
|
};
|
|
371
721
|
};
|
|
372
722
|
};
|
|
373
|
-
|
|
723
|
+
UploadsController_getUploadStatus: {
|
|
374
724
|
parameters: {
|
|
725
|
+
query?: {
|
|
726
|
+
/** @description Upload ID to get status for */
|
|
727
|
+
uploadId?: string;
|
|
728
|
+
/** @description Upload name to get status for */
|
|
729
|
+
name?: string;
|
|
730
|
+
};
|
|
375
731
|
header: {
|
|
376
732
|
"x-app-api-key": string;
|
|
377
733
|
};
|
|
378
|
-
path
|
|
379
|
-
|
|
380
|
-
};
|
|
734
|
+
path?: never;
|
|
735
|
+
cookie?: never;
|
|
381
736
|
};
|
|
737
|
+
requestBody?: never;
|
|
382
738
|
responses: {
|
|
383
|
-
/** @description
|
|
739
|
+
/** @description Upload status */
|
|
384
740
|
200: {
|
|
741
|
+
headers: {
|
|
742
|
+
[name: string]: unknown;
|
|
743
|
+
};
|
|
385
744
|
content: {
|
|
386
|
-
|
|
745
|
+
/**
|
|
746
|
+
* @example {
|
|
747
|
+
* "uploadId": "upload-123",
|
|
748
|
+
* "status": "PENDING",
|
|
749
|
+
* "tests": [
|
|
750
|
+
* {
|
|
751
|
+
* "id": 1,
|
|
752
|
+
* "test_file_name": "test-flow.yaml",
|
|
753
|
+
* "status": "PENDING"
|
|
754
|
+
* }
|
|
755
|
+
* ]
|
|
756
|
+
* }
|
|
757
|
+
*/
|
|
758
|
+
"application/json": Record<string, never>;
|
|
387
759
|
};
|
|
388
760
|
};
|
|
389
761
|
};
|
|
390
762
|
};
|
|
391
|
-
|
|
763
|
+
UploadsController_deleteUpload: {
|
|
392
764
|
parameters: {
|
|
765
|
+
query?: never;
|
|
393
766
|
header: {
|
|
394
767
|
"x-app-api-key": string;
|
|
395
768
|
};
|
|
769
|
+
path: {
|
|
770
|
+
uploadId: string;
|
|
771
|
+
};
|
|
772
|
+
cookie?: never;
|
|
396
773
|
};
|
|
774
|
+
requestBody?: never;
|
|
397
775
|
responses: {
|
|
398
|
-
/** @description Device compatibility lookup data */
|
|
399
776
|
200: {
|
|
777
|
+
headers: {
|
|
778
|
+
[name: string]: unknown;
|
|
779
|
+
};
|
|
780
|
+
content?: never;
|
|
781
|
+
};
|
|
782
|
+
/** @description The upload has been successfully deleted. */
|
|
783
|
+
201: {
|
|
784
|
+
headers: {
|
|
785
|
+
[name: string]: unknown;
|
|
786
|
+
};
|
|
400
787
|
content: {
|
|
401
788
|
"application/json": {
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
androidPlay?: Record<string, never>;
|
|
405
|
-
ios?: Record<string, never>;
|
|
406
|
-
};
|
|
407
|
-
statusCode?: number;
|
|
789
|
+
success?: boolean;
|
|
790
|
+
message?: string;
|
|
408
791
|
};
|
|
409
792
|
};
|
|
410
793
|
};
|
|
@@ -412,20 +795,26 @@ export interface operations {
|
|
|
412
795
|
};
|
|
413
796
|
ResultsController_getResults: {
|
|
414
797
|
parameters: {
|
|
798
|
+
query?: never;
|
|
415
799
|
header: {
|
|
416
800
|
"x-app-api-key": string;
|
|
417
801
|
};
|
|
418
802
|
path: {
|
|
419
803
|
uploadId: string;
|
|
420
804
|
};
|
|
805
|
+
cookie?: never;
|
|
421
806
|
};
|
|
807
|
+
requestBody?: never;
|
|
422
808
|
responses: {
|
|
423
809
|
/** @description The record has been successfully created. */
|
|
424
810
|
200: {
|
|
811
|
+
headers: {
|
|
812
|
+
[name: string]: unknown;
|
|
813
|
+
};
|
|
425
814
|
content: {
|
|
426
815
|
"application/json": {
|
|
427
|
-
results?: components["schemas"]["TResultResponse"][];
|
|
428
816
|
statusCode?: number;
|
|
817
|
+
results?: components["schemas"]["TResultResponse"][];
|
|
429
818
|
};
|
|
430
819
|
};
|
|
431
820
|
};
|
|
@@ -433,342 +822,691 @@ export interface operations {
|
|
|
433
822
|
};
|
|
434
823
|
ResultsController_getTestRunArtifacts: {
|
|
435
824
|
parameters: {
|
|
825
|
+
query?: never;
|
|
436
826
|
header: {
|
|
437
827
|
"x-app-api-key": string;
|
|
438
828
|
};
|
|
439
829
|
path: {
|
|
440
830
|
uploadId: string;
|
|
441
831
|
};
|
|
832
|
+
cookie?: never;
|
|
442
833
|
};
|
|
834
|
+
requestBody?: never;
|
|
443
835
|
responses: {
|
|
444
836
|
201: {
|
|
445
|
-
|
|
837
|
+
headers: {
|
|
838
|
+
[name: string]: unknown;
|
|
839
|
+
};
|
|
840
|
+
content?: never;
|
|
446
841
|
};
|
|
447
842
|
};
|
|
448
843
|
};
|
|
449
844
|
ResultsController_notifyTestRunComplete: {
|
|
450
845
|
parameters: {
|
|
846
|
+
query?: never;
|
|
451
847
|
header: {
|
|
452
848
|
"x-app-api-key": string;
|
|
453
849
|
};
|
|
454
850
|
path: {
|
|
455
851
|
uploadId: string;
|
|
456
852
|
};
|
|
853
|
+
cookie?: never;
|
|
457
854
|
};
|
|
855
|
+
requestBody?: never;
|
|
458
856
|
responses: {
|
|
459
857
|
/** @description Send results summary email. */
|
|
460
858
|
201: {
|
|
859
|
+
headers: {
|
|
860
|
+
[name: string]: unknown;
|
|
861
|
+
};
|
|
461
862
|
content: {
|
|
462
863
|
"application/json": string;
|
|
463
864
|
};
|
|
464
865
|
};
|
|
465
866
|
};
|
|
466
867
|
};
|
|
467
|
-
|
|
868
|
+
ResultsController_downloadReport: {
|
|
468
869
|
parameters: {
|
|
870
|
+
query?: never;
|
|
469
871
|
header: {
|
|
470
872
|
"x-app-api-key": string;
|
|
471
873
|
};
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
content: {
|
|
475
|
-
"application/json": components["schemas"]["ICancelTestArgs"];
|
|
874
|
+
path: {
|
|
875
|
+
uploadId: string;
|
|
476
876
|
};
|
|
877
|
+
cookie?: never;
|
|
477
878
|
};
|
|
879
|
+
requestBody?: never;
|
|
478
880
|
responses: {
|
|
479
|
-
/** @description
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
cancelledCount?: number;
|
|
484
|
-
message?: string;
|
|
485
|
-
success?: boolean;
|
|
486
|
-
};
|
|
881
|
+
/** @description Download combined JUNIT test report (report.xml) for the upload */
|
|
882
|
+
200: {
|
|
883
|
+
headers: {
|
|
884
|
+
[name: string]: unknown;
|
|
487
885
|
};
|
|
488
|
-
};
|
|
489
|
-
};
|
|
490
|
-
};
|
|
491
|
-
UploadsController_checkForExistingUpload: {
|
|
492
|
-
parameters: {
|
|
493
|
-
header: {
|
|
494
|
-
"x-app-api-key": string;
|
|
495
|
-
};
|
|
496
|
-
};
|
|
497
|
-
requestBody: {
|
|
498
|
-
content: {
|
|
499
|
-
"application/json": components["schemas"]["ICheckForExistingUploadArgs"];
|
|
500
|
-
};
|
|
501
|
-
};
|
|
502
|
-
responses: {
|
|
503
|
-
/** @description The url has been successfully created. */
|
|
504
|
-
201: {
|
|
505
886
|
content: {
|
|
506
|
-
"application/json":
|
|
887
|
+
"application/json": string;
|
|
507
888
|
};
|
|
508
889
|
};
|
|
509
890
|
};
|
|
510
891
|
};
|
|
511
|
-
|
|
892
|
+
ResultsController_downloadHtmlReport: {
|
|
512
893
|
parameters: {
|
|
894
|
+
query?: never;
|
|
513
895
|
header: {
|
|
514
896
|
"x-app-api-key": string;
|
|
515
897
|
};
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
content: {
|
|
519
|
-
"multipart/form-data": components["schemas"]["ICreateBinaryUploadArgs"];
|
|
898
|
+
path: {
|
|
899
|
+
uploadId: string;
|
|
520
900
|
};
|
|
901
|
+
cookie?: never;
|
|
521
902
|
};
|
|
903
|
+
requestBody?: never;
|
|
522
904
|
responses: {
|
|
523
|
-
/**
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
* }
|
|
529
|
-
*/
|
|
530
|
-
201: {
|
|
905
|
+
/** @description Download combined HTML test report (report.html) for the upload */
|
|
906
|
+
200: {
|
|
907
|
+
headers: {
|
|
908
|
+
[name: string]: unknown;
|
|
909
|
+
};
|
|
531
910
|
content: {
|
|
532
|
-
"application/json":
|
|
911
|
+
"application/json": string;
|
|
533
912
|
};
|
|
534
913
|
};
|
|
535
914
|
};
|
|
536
915
|
};
|
|
537
|
-
|
|
916
|
+
ResultsController_getCompatibilityData: {
|
|
538
917
|
parameters: {
|
|
918
|
+
query?: never;
|
|
539
919
|
header: {
|
|
540
920
|
"x-app-api-key": string;
|
|
541
921
|
};
|
|
922
|
+
path?: never;
|
|
923
|
+
cookie?: never;
|
|
542
924
|
};
|
|
543
|
-
requestBody
|
|
544
|
-
content: {
|
|
545
|
-
"multipart/form-data": components["schemas"]["ICreateTestUploadArgs"];
|
|
546
|
-
};
|
|
547
|
-
};
|
|
925
|
+
requestBody?: never;
|
|
548
926
|
responses: {
|
|
549
|
-
/** @description
|
|
550
|
-
|
|
927
|
+
/** @description Device compatibility lookup data including Maestro versions */
|
|
928
|
+
200: {
|
|
929
|
+
headers: {
|
|
930
|
+
[name: string]: unknown;
|
|
931
|
+
};
|
|
551
932
|
content: {
|
|
933
|
+
/**
|
|
934
|
+
* @example {
|
|
935
|
+
* "statusCode": 200,
|
|
936
|
+
* "data": {
|
|
937
|
+
* "ios": {
|
|
938
|
+
* "iphone-14": {
|
|
939
|
+
* "name": "iPhone 14",
|
|
940
|
+
* "versions": [
|
|
941
|
+
* "15",
|
|
942
|
+
* "16",
|
|
943
|
+
* "17",
|
|
944
|
+
* "18"
|
|
945
|
+
* ],
|
|
946
|
+
* "deprecated": false
|
|
947
|
+
* },
|
|
948
|
+
* "iphone-14-pro": {
|
|
949
|
+
* "name": "iPhone 14 Pro",
|
|
950
|
+
* "versions": [
|
|
951
|
+
* "15",
|
|
952
|
+
* "16",
|
|
953
|
+
* "17",
|
|
954
|
+
* "18"
|
|
955
|
+
* ],
|
|
956
|
+
* "deprecated": false
|
|
957
|
+
* },
|
|
958
|
+
* "iphone-15": {
|
|
959
|
+
* "name": "iPhone 15",
|
|
960
|
+
* "versions": [
|
|
961
|
+
* "16",
|
|
962
|
+
* "17",
|
|
963
|
+
* "18"
|
|
964
|
+
* ],
|
|
965
|
+
* "deprecated": false
|
|
966
|
+
* },
|
|
967
|
+
* "iphone-15-pro": {
|
|
968
|
+
* "name": "iPhone 15 Pro",
|
|
969
|
+
* "versions": [
|
|
970
|
+
* "16",
|
|
971
|
+
* "17",
|
|
972
|
+
* "18"
|
|
973
|
+
* ],
|
|
974
|
+
* "deprecated": false
|
|
975
|
+
* },
|
|
976
|
+
* "iphone-16": {
|
|
977
|
+
* "name": "iPhone 16",
|
|
978
|
+
* "versions": [
|
|
979
|
+
* "17",
|
|
980
|
+
* "18"
|
|
981
|
+
* ],
|
|
982
|
+
* "deprecated": false
|
|
983
|
+
* },
|
|
984
|
+
* "iphone-16-plus": {
|
|
985
|
+
* "name": "iPhone 16 Plus",
|
|
986
|
+
* "versions": [
|
|
987
|
+
* "17",
|
|
988
|
+
* "18"
|
|
989
|
+
* ],
|
|
990
|
+
* "deprecated": false
|
|
991
|
+
* },
|
|
992
|
+
* "iphone-16-pro": {
|
|
993
|
+
* "name": "iPhone 16 Pro",
|
|
994
|
+
* "versions": [
|
|
995
|
+
* "17",
|
|
996
|
+
* "18"
|
|
997
|
+
* ],
|
|
998
|
+
* "deprecated": false
|
|
999
|
+
* },
|
|
1000
|
+
* "iphone-16-pro-max": {
|
|
1001
|
+
* "name": "iPhone 16 Pro Max",
|
|
1002
|
+
* "versions": [
|
|
1003
|
+
* "17",
|
|
1004
|
+
* "18"
|
|
1005
|
+
* ],
|
|
1006
|
+
* "deprecated": false
|
|
1007
|
+
* },
|
|
1008
|
+
* "iphone-13": {
|
|
1009
|
+
* "name": "iPhone 13",
|
|
1010
|
+
* "versions": [
|
|
1011
|
+
* "15",
|
|
1012
|
+
* "16",
|
|
1013
|
+
* "17"
|
|
1014
|
+
* ],
|
|
1015
|
+
* "deprecated": true
|
|
1016
|
+
* },
|
|
1017
|
+
* "ipad-air": {
|
|
1018
|
+
* "name": "iPad Air",
|
|
1019
|
+
* "versions": [
|
|
1020
|
+
* "15",
|
|
1021
|
+
* "16",
|
|
1022
|
+
* "17"
|
|
1023
|
+
* ],
|
|
1024
|
+
* "deprecated": false
|
|
1025
|
+
* },
|
|
1026
|
+
* "ipad-pro-6th-gen": {
|
|
1027
|
+
* "name": "iPad Pro (6th gen)",
|
|
1028
|
+
* "versions": [
|
|
1029
|
+
* "16",
|
|
1030
|
+
* "17",
|
|
1031
|
+
* "18"
|
|
1032
|
+
* ],
|
|
1033
|
+
* "deprecated": false
|
|
1034
|
+
* }
|
|
1035
|
+
* },
|
|
1036
|
+
* "android": {
|
|
1037
|
+
* "pixel-6": {
|
|
1038
|
+
* "name": "Pixel 6",
|
|
1039
|
+
* "apiLevels": [
|
|
1040
|
+
* "29",
|
|
1041
|
+
* "30",
|
|
1042
|
+
* "31",
|
|
1043
|
+
* "32",
|
|
1044
|
+
* "33"
|
|
1045
|
+
* ],
|
|
1046
|
+
* "deprecated": false
|
|
1047
|
+
* },
|
|
1048
|
+
* "pixel-6-pro": {
|
|
1049
|
+
* "name": "Pixel 6 Pro",
|
|
1050
|
+
* "apiLevels": [
|
|
1051
|
+
* "29",
|
|
1052
|
+
* "30",
|
|
1053
|
+
* "31",
|
|
1054
|
+
* "32",
|
|
1055
|
+
* "33"
|
|
1056
|
+
* ],
|
|
1057
|
+
* "deprecated": false
|
|
1058
|
+
* },
|
|
1059
|
+
* "pixel-7": {
|
|
1060
|
+
* "name": "Pixel 7",
|
|
1061
|
+
* "apiLevels": [
|
|
1062
|
+
* "30",
|
|
1063
|
+
* "31",
|
|
1064
|
+
* "32",
|
|
1065
|
+
* "33",
|
|
1066
|
+
* "34"
|
|
1067
|
+
* ],
|
|
1068
|
+
* "deprecated": false
|
|
1069
|
+
* },
|
|
1070
|
+
* "pixel-7-pro": {
|
|
1071
|
+
* "name": "Pixel 7 Pro",
|
|
1072
|
+
* "apiLevels": [
|
|
1073
|
+
* "30",
|
|
1074
|
+
* "31",
|
|
1075
|
+
* "32",
|
|
1076
|
+
* "33",
|
|
1077
|
+
* "34"
|
|
1078
|
+
* ],
|
|
1079
|
+
* "deprecated": false
|
|
1080
|
+
* },
|
|
1081
|
+
* "generic-tablet": {
|
|
1082
|
+
* "name": "Generic Tablet",
|
|
1083
|
+
* "apiLevels": [
|
|
1084
|
+
* "29",
|
|
1085
|
+
* "30",
|
|
1086
|
+
* "31",
|
|
1087
|
+
* "32",
|
|
1088
|
+
* "33",
|
|
1089
|
+
* "34",
|
|
1090
|
+
* "35"
|
|
1091
|
+
* ],
|
|
1092
|
+
* "deprecated": false
|
|
1093
|
+
* }
|
|
1094
|
+
* },
|
|
1095
|
+
* "androidPlay": {
|
|
1096
|
+
* "pixel-6": {
|
|
1097
|
+
* "name": "Pixel 6 (Google Play)",
|
|
1098
|
+
* "apiLevels": [
|
|
1099
|
+
* "29",
|
|
1100
|
+
* "30",
|
|
1101
|
+
* "31",
|
|
1102
|
+
* "32",
|
|
1103
|
+
* "33"
|
|
1104
|
+
* ],
|
|
1105
|
+
* "deprecated": false
|
|
1106
|
+
* },
|
|
1107
|
+
* "pixel-7": {
|
|
1108
|
+
* "name": "Pixel 7 (Google Play)",
|
|
1109
|
+
* "apiLevels": [
|
|
1110
|
+
* "30",
|
|
1111
|
+
* "31",
|
|
1112
|
+
* "32",
|
|
1113
|
+
* "33",
|
|
1114
|
+
* "34"
|
|
1115
|
+
* ],
|
|
1116
|
+
* "deprecated": false
|
|
1117
|
+
* }
|
|
1118
|
+
* },
|
|
1119
|
+
* "maestro": {
|
|
1120
|
+
* "supportedVersions": [
|
|
1121
|
+
* "1.39.0",
|
|
1122
|
+
* "1.39.1",
|
|
1123
|
+
* "1.39.2",
|
|
1124
|
+
* "1.39.5",
|
|
1125
|
+
* "1.39.7",
|
|
1126
|
+
* "1.40.3",
|
|
1127
|
+
* "1.41.0",
|
|
1128
|
+
* "2.0.2",
|
|
1129
|
+
* "2.0.3",
|
|
1130
|
+
* "2.0.4"
|
|
1131
|
+
* ],
|
|
1132
|
+
* "defaultVersion": "1.41.0",
|
|
1133
|
+
* "latestVersion": "2.0.4"
|
|
1134
|
+
* }
|
|
1135
|
+
* }
|
|
1136
|
+
* }
|
|
1137
|
+
*/
|
|
552
1138
|
"application/json": {
|
|
553
|
-
|
|
554
|
-
|
|
1139
|
+
statusCode?: number;
|
|
1140
|
+
data?: {
|
|
1141
|
+
ios?: Record<string, never>;
|
|
1142
|
+
android?: Record<string, never>;
|
|
1143
|
+
androidPlay?: Record<string, never>;
|
|
1144
|
+
maestro?: {
|
|
1145
|
+
supportedVersions?: string[];
|
|
1146
|
+
defaultVersion?: string;
|
|
1147
|
+
latestVersion?: string;
|
|
1148
|
+
};
|
|
1149
|
+
};
|
|
555
1150
|
};
|
|
556
1151
|
};
|
|
557
1152
|
};
|
|
558
1153
|
};
|
|
559
1154
|
};
|
|
560
|
-
|
|
1155
|
+
AllureController_downloadAllureReport: {
|
|
561
1156
|
parameters: {
|
|
1157
|
+
query?: never;
|
|
562
1158
|
header: {
|
|
563
1159
|
"x-app-api-key": string;
|
|
564
1160
|
};
|
|
565
1161
|
path: {
|
|
1162
|
+
/** @description The upload ID to generate Allure report for */
|
|
566
1163
|
uploadId: string;
|
|
567
1164
|
};
|
|
1165
|
+
cookie?: never;
|
|
568
1166
|
};
|
|
1167
|
+
requestBody?: never;
|
|
569
1168
|
responses: {
|
|
1169
|
+
/** @description Allure report HTML file download */
|
|
570
1170
|
200: {
|
|
571
|
-
|
|
1171
|
+
headers: {
|
|
1172
|
+
[name: string]: unknown;
|
|
1173
|
+
};
|
|
1174
|
+
content: {
|
|
1175
|
+
"text/html": string;
|
|
1176
|
+
};
|
|
572
1177
|
};
|
|
573
|
-
/** @description
|
|
574
|
-
|
|
1178
|
+
/** @description Upload not found or no results available */
|
|
1179
|
+
404: {
|
|
1180
|
+
headers: {
|
|
1181
|
+
[name: string]: unknown;
|
|
1182
|
+
};
|
|
1183
|
+
content?: never;
|
|
1184
|
+
};
|
|
1185
|
+
};
|
|
1186
|
+
};
|
|
1187
|
+
WebhooksController_getWebhook: {
|
|
1188
|
+
parameters: {
|
|
1189
|
+
query?: {
|
|
1190
|
+
/** @description Set to true to return full secret instead of masked version */
|
|
1191
|
+
show_secret?: boolean;
|
|
1192
|
+
};
|
|
1193
|
+
header: {
|
|
1194
|
+
"x-app-api-key": string;
|
|
1195
|
+
};
|
|
1196
|
+
path?: never;
|
|
1197
|
+
cookie?: never;
|
|
1198
|
+
};
|
|
1199
|
+
requestBody?: never;
|
|
1200
|
+
responses: {
|
|
1201
|
+
/** @description Current webhook configuration */
|
|
1202
|
+
200: {
|
|
1203
|
+
headers: {
|
|
1204
|
+
[name: string]: unknown;
|
|
1205
|
+
};
|
|
575
1206
|
content: {
|
|
576
1207
|
"application/json": {
|
|
577
|
-
|
|
578
|
-
|
|
1208
|
+
webhook_url?: string;
|
|
1209
|
+
/** @description Full secret (only when show_secret=true) */
|
|
1210
|
+
secret_key?: string;
|
|
1211
|
+
/** @description Masked secret (default) */
|
|
1212
|
+
secret_key_masked?: string;
|
|
1213
|
+
/** Format: date-time */
|
|
1214
|
+
created_at?: string;
|
|
1215
|
+
/** Format: date-time */
|
|
1216
|
+
updated_at?: string;
|
|
579
1217
|
};
|
|
580
1218
|
};
|
|
581
1219
|
};
|
|
582
1220
|
};
|
|
583
1221
|
};
|
|
584
|
-
|
|
1222
|
+
WebhooksController_setWebhook: {
|
|
585
1223
|
parameters: {
|
|
1224
|
+
query?: never;
|
|
586
1225
|
header: {
|
|
587
1226
|
"x-app-api-key": string;
|
|
588
1227
|
};
|
|
1228
|
+
path?: never;
|
|
1229
|
+
cookie?: never;
|
|
589
1230
|
};
|
|
590
1231
|
requestBody: {
|
|
591
1232
|
content: {
|
|
592
|
-
"application/json":
|
|
1233
|
+
"application/json": {
|
|
1234
|
+
/**
|
|
1235
|
+
* Format: uri
|
|
1236
|
+
* @example https://api.example.com/webhook
|
|
1237
|
+
*/
|
|
1238
|
+
url: string;
|
|
1239
|
+
};
|
|
593
1240
|
};
|
|
594
1241
|
};
|
|
595
1242
|
responses: {
|
|
596
|
-
/** @description
|
|
1243
|
+
/** @description Webhook URL set successfully */
|
|
597
1244
|
201: {
|
|
1245
|
+
headers: {
|
|
1246
|
+
[name: string]: unknown;
|
|
1247
|
+
};
|
|
598
1248
|
content: {
|
|
599
|
-
"application/json":
|
|
1249
|
+
"application/json": Record<string, never>;
|
|
600
1250
|
};
|
|
601
1251
|
};
|
|
602
1252
|
};
|
|
603
1253
|
};
|
|
604
|
-
|
|
1254
|
+
WebhooksController_deleteWebhook: {
|
|
605
1255
|
parameters: {
|
|
1256
|
+
query?: never;
|
|
606
1257
|
header: {
|
|
607
1258
|
"x-app-api-key": string;
|
|
608
1259
|
};
|
|
1260
|
+
path?: never;
|
|
1261
|
+
cookie?: never;
|
|
609
1262
|
};
|
|
610
|
-
requestBody
|
|
611
|
-
content: {
|
|
612
|
-
"application/json": components["schemas"]["IGetBinaryUploadUrlArgs"];
|
|
613
|
-
};
|
|
614
|
-
};
|
|
1263
|
+
requestBody?: never;
|
|
615
1264
|
responses: {
|
|
616
|
-
/** @description
|
|
617
|
-
|
|
1265
|
+
/** @description Webhook configuration deleted successfully */
|
|
1266
|
+
200: {
|
|
1267
|
+
headers: {
|
|
1268
|
+
[name: string]: unknown;
|
|
1269
|
+
};
|
|
618
1270
|
content: {
|
|
619
|
-
"application/json":
|
|
1271
|
+
"application/json": Record<string, never>;
|
|
620
1272
|
};
|
|
621
1273
|
};
|
|
622
1274
|
};
|
|
623
1275
|
};
|
|
624
|
-
|
|
1276
|
+
WebhooksController_regenerateWebhookSecret: {
|
|
625
1277
|
parameters: {
|
|
1278
|
+
query?: never;
|
|
626
1279
|
header: {
|
|
627
1280
|
"x-app-api-key": string;
|
|
628
1281
|
};
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
name?: string;
|
|
632
|
-
/** @description Upload ID to get status for */
|
|
633
|
-
uploadId?: string;
|
|
634
|
-
};
|
|
1282
|
+
path?: never;
|
|
1283
|
+
cookie?: never;
|
|
635
1284
|
};
|
|
1285
|
+
requestBody?: never;
|
|
636
1286
|
responses: {
|
|
637
|
-
/** @description
|
|
638
|
-
|
|
1287
|
+
/** @description Webhook secret regenerated successfully */
|
|
1288
|
+
201: {
|
|
1289
|
+
headers: {
|
|
1290
|
+
[name: string]: unknown;
|
|
1291
|
+
};
|
|
639
1292
|
content: {
|
|
640
1293
|
"application/json": Record<string, never>;
|
|
641
1294
|
};
|
|
642
1295
|
};
|
|
643
1296
|
};
|
|
644
1297
|
};
|
|
645
|
-
|
|
1298
|
+
WebhooksController_testWebhook: {
|
|
646
1299
|
parameters: {
|
|
1300
|
+
query?: never;
|
|
647
1301
|
header: {
|
|
648
1302
|
"x-app-api-key": string;
|
|
649
1303
|
};
|
|
1304
|
+
path?: never;
|
|
1305
|
+
cookie?: never;
|
|
650
1306
|
};
|
|
651
1307
|
requestBody: {
|
|
652
1308
|
content: {
|
|
653
|
-
"application/json":
|
|
1309
|
+
"application/json": {
|
|
1310
|
+
/** Format: uri */
|
|
1311
|
+
url?: string;
|
|
1312
|
+
};
|
|
654
1313
|
};
|
|
655
1314
|
};
|
|
656
1315
|
responses: {
|
|
657
|
-
/** @description
|
|
1316
|
+
/** @description Test webhook sent successfully */
|
|
658
1317
|
201: {
|
|
1318
|
+
headers: {
|
|
1319
|
+
[name: string]: unknown;
|
|
1320
|
+
};
|
|
659
1321
|
content: {
|
|
660
|
-
"application/json":
|
|
661
|
-
message?: string;
|
|
662
|
-
results?: components["schemas"]["IDBResult"][];
|
|
663
|
-
};
|
|
1322
|
+
"application/json": Record<string, never>;
|
|
664
1323
|
};
|
|
665
1324
|
};
|
|
666
1325
|
};
|
|
667
1326
|
};
|
|
668
|
-
|
|
1327
|
+
OrgController_paddleTransactionCompleted: {
|
|
669
1328
|
parameters: {
|
|
1329
|
+
query?: never;
|
|
670
1330
|
header: {
|
|
671
|
-
"
|
|
1331
|
+
"paddle-signature": string;
|
|
672
1332
|
};
|
|
1333
|
+
path?: never;
|
|
1334
|
+
cookie?: never;
|
|
673
1335
|
};
|
|
1336
|
+
requestBody?: never;
|
|
674
1337
|
responses: {
|
|
675
|
-
/** @description
|
|
676
|
-
|
|
1338
|
+
/** @description Success. */
|
|
1339
|
+
201: {
|
|
1340
|
+
headers: {
|
|
1341
|
+
[name: string]: unknown;
|
|
1342
|
+
};
|
|
677
1343
|
content: {
|
|
678
|
-
"application/json":
|
|
1344
|
+
"application/json": string;
|
|
679
1345
|
};
|
|
680
1346
|
};
|
|
681
1347
|
};
|
|
682
1348
|
};
|
|
683
|
-
|
|
1349
|
+
OrgController_updateOrgName: {
|
|
684
1350
|
parameters: {
|
|
1351
|
+
query?: never;
|
|
685
1352
|
header: {
|
|
686
1353
|
"x-app-api-key": string;
|
|
687
1354
|
};
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
1355
|
+
path?: never;
|
|
1356
|
+
cookie?: never;
|
|
1357
|
+
};
|
|
1358
|
+
requestBody: {
|
|
1359
|
+
content: {
|
|
1360
|
+
"application/json": {
|
|
1361
|
+
orgId: string;
|
|
1362
|
+
name: string;
|
|
1363
|
+
};
|
|
691
1364
|
};
|
|
692
1365
|
};
|
|
693
1366
|
responses: {
|
|
694
|
-
/** @description
|
|
695
|
-
|
|
1367
|
+
/** @description Organization name updated successfully. */
|
|
1368
|
+
201: {
|
|
1369
|
+
headers: {
|
|
1370
|
+
[name: string]: unknown;
|
|
1371
|
+
};
|
|
696
1372
|
content: {
|
|
697
|
-
"application/json":
|
|
698
|
-
/** Format: date-time */
|
|
699
|
-
created_at?: string;
|
|
700
|
-
/** @description Full secret (only when show_secret=true) */
|
|
701
|
-
secret_key?: string;
|
|
702
|
-
/** @description Masked secret (default) */
|
|
703
|
-
secret_key_masked?: string;
|
|
704
|
-
/** Format: date-time */
|
|
705
|
-
updated_at?: string;
|
|
706
|
-
webhook_url?: string;
|
|
707
|
-
};
|
|
1373
|
+
"application/json": boolean;
|
|
708
1374
|
};
|
|
709
1375
|
};
|
|
710
1376
|
};
|
|
711
1377
|
};
|
|
712
|
-
|
|
1378
|
+
OrgController_inviteTeamMember: {
|
|
713
1379
|
parameters: {
|
|
1380
|
+
query?: never;
|
|
714
1381
|
header: {
|
|
715
1382
|
"x-app-api-key": string;
|
|
716
1383
|
};
|
|
1384
|
+
path?: never;
|
|
1385
|
+
cookie?: never;
|
|
1386
|
+
};
|
|
1387
|
+
requestBody: {
|
|
1388
|
+
content: {
|
|
1389
|
+
"application/json": {
|
|
1390
|
+
inviteEmail: string;
|
|
1391
|
+
requesterEmail: string;
|
|
1392
|
+
link: string;
|
|
1393
|
+
orgId: string;
|
|
1394
|
+
orgName: string;
|
|
1395
|
+
};
|
|
1396
|
+
};
|
|
717
1397
|
};
|
|
718
1398
|
responses: {
|
|
719
|
-
/** @description
|
|
1399
|
+
/** @description Team member invited successfully. */
|
|
720
1400
|
201: {
|
|
1401
|
+
headers: {
|
|
1402
|
+
[name: string]: unknown;
|
|
1403
|
+
};
|
|
721
1404
|
content: {
|
|
722
|
-
"application/json":
|
|
1405
|
+
"application/json": boolean;
|
|
723
1406
|
};
|
|
724
1407
|
};
|
|
725
1408
|
};
|
|
726
1409
|
};
|
|
727
|
-
|
|
1410
|
+
OrgController_acceptInvite: {
|
|
728
1411
|
parameters: {
|
|
1412
|
+
query?: never;
|
|
729
1413
|
header: {
|
|
730
1414
|
"x-app-api-key": string;
|
|
731
1415
|
};
|
|
1416
|
+
path?: never;
|
|
1417
|
+
cookie?: never;
|
|
732
1418
|
};
|
|
733
1419
|
requestBody: {
|
|
734
1420
|
content: {
|
|
735
1421
|
"application/json": {
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
* @example https://api.example.com/webhook
|
|
739
|
-
*/
|
|
740
|
-
url: string;
|
|
1422
|
+
orgId: string;
|
|
1423
|
+
email: string;
|
|
741
1424
|
};
|
|
742
1425
|
};
|
|
743
1426
|
};
|
|
744
1427
|
responses: {
|
|
745
|
-
/** @description
|
|
1428
|
+
/** @description Team invite accepted successfully. */
|
|
746
1429
|
201: {
|
|
1430
|
+
headers: {
|
|
1431
|
+
[name: string]: unknown;
|
|
1432
|
+
};
|
|
747
1433
|
content: {
|
|
748
|
-
"application/json":
|
|
1434
|
+
"application/json": boolean;
|
|
749
1435
|
};
|
|
750
1436
|
};
|
|
751
1437
|
};
|
|
752
1438
|
};
|
|
753
|
-
|
|
1439
|
+
FrontendController_checkDomainSaml: {
|
|
754
1440
|
parameters: {
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
1441
|
+
query?: never;
|
|
1442
|
+
header?: never;
|
|
1443
|
+
path?: never;
|
|
1444
|
+
cookie?: never;
|
|
758
1445
|
};
|
|
1446
|
+
/** @description Domain to check for SAML configuration */
|
|
759
1447
|
requestBody: {
|
|
760
1448
|
content: {
|
|
761
1449
|
"application/json": {
|
|
762
|
-
/**
|
|
763
|
-
|
|
1450
|
+
/** @example example.com */
|
|
1451
|
+
domain: string;
|
|
764
1452
|
};
|
|
765
1453
|
};
|
|
766
1454
|
};
|
|
767
1455
|
responses: {
|
|
768
|
-
/** @description
|
|
1456
|
+
/** @description SAML status for the domain */
|
|
1457
|
+
200: {
|
|
1458
|
+
headers: {
|
|
1459
|
+
[name: string]: unknown;
|
|
1460
|
+
};
|
|
1461
|
+
content: {
|
|
1462
|
+
"application/json": {
|
|
1463
|
+
forceSaml?: boolean;
|
|
1464
|
+
};
|
|
1465
|
+
};
|
|
1466
|
+
};
|
|
769
1467
|
201: {
|
|
1468
|
+
headers: {
|
|
1469
|
+
[name: string]: unknown;
|
|
1470
|
+
};
|
|
1471
|
+
content?: never;
|
|
1472
|
+
};
|
|
1473
|
+
/** @description Bad request - invalid domain or API error */
|
|
1474
|
+
400: {
|
|
1475
|
+
headers: {
|
|
1476
|
+
[name: string]: unknown;
|
|
1477
|
+
};
|
|
770
1478
|
content: {
|
|
771
|
-
"application/json":
|
|
1479
|
+
"application/json": {
|
|
1480
|
+
error?: string;
|
|
1481
|
+
};
|
|
1482
|
+
};
|
|
1483
|
+
};
|
|
1484
|
+
};
|
|
1485
|
+
};
|
|
1486
|
+
HealthController_health: {
|
|
1487
|
+
parameters: {
|
|
1488
|
+
query?: never;
|
|
1489
|
+
header?: never;
|
|
1490
|
+
path?: never;
|
|
1491
|
+
cookie?: never;
|
|
1492
|
+
};
|
|
1493
|
+
requestBody?: never;
|
|
1494
|
+
responses: {
|
|
1495
|
+
/** @description Health check endpoint */
|
|
1496
|
+
200: {
|
|
1497
|
+
headers: {
|
|
1498
|
+
[name: string]: unknown;
|
|
1499
|
+
};
|
|
1500
|
+
content: {
|
|
1501
|
+
/**
|
|
1502
|
+
* @example {
|
|
1503
|
+
* "status": "ok"
|
|
1504
|
+
* }
|
|
1505
|
+
*/
|
|
1506
|
+
"application/json": {
|
|
1507
|
+
/** @example ok */
|
|
1508
|
+
status?: string;
|
|
1509
|
+
};
|
|
772
1510
|
};
|
|
773
1511
|
};
|
|
774
1512
|
};
|