@serkonda7/unifi-api 0.0.0-stage → 0.1.0
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/README.md +149 -2
- package/dist/generated/client/client.gen.d.ts +2 -0
- package/dist/generated/client/index.d.ts +10 -0
- package/dist/generated/client/types.gen.d.ts +120 -0
- package/dist/generated/client/utils.gen.d.ts +37 -0
- package/dist/generated/client.gen.d.ts +12 -0
- package/dist/generated/core/auth.gen.d.ts +25 -0
- package/dist/generated/core/bodySerializer.gen.d.ts +25 -0
- package/dist/generated/core/params.gen.d.ts +43 -0
- package/dist/generated/core/pathSerializer.gen.d.ts +33 -0
- package/dist/generated/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/generated/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/generated/core/types.gen.d.ts +83 -0
- package/dist/generated/core/utils.gen.d.ts +19 -0
- package/dist/generated/index.d.ts +2 -0
- package/dist/generated/sdk.gen.d.ts +99 -0
- package/dist/generated/types.gen.d.ts +2718 -0
- package/dist/index.d.ts +6 -0
- package/dist/index.js +6 -0
- package/dist/shared/client.d.ts +26 -0
- package/dist/shared/errors.d.ts +47 -0
- package/dist/shared/pagination.d.ts +18 -0
- package/dist/site-manager/client.d.ts +32 -0
- package/dist/site-manager/index.d.ts +64 -0
- package/dist/site-manager/resources/connector.d.ts +107 -0
- package/dist/site-manager/resources/devices.d.ts +36 -0
- package/dist/site-manager/resources/hosts.d.ts +41 -0
- package/dist/site-manager/resources/ispMetrics.d.ts +48 -0
- package/dist/site-manager/resources/sdWan.d.ts +27 -0
- package/dist/site-manager/resources/sites.d.ts +34 -0
- package/package.json +52 -4
|
@@ -0,0 +1,2718 @@
|
|
|
1
|
+
export type ClientOptions = {
|
|
2
|
+
baseUrl: 'https://api.ui.com' | (string & {});
|
|
3
|
+
};
|
|
4
|
+
export type ConnectorDeleteData = {
|
|
5
|
+
body?: never;
|
|
6
|
+
path: {
|
|
7
|
+
/**
|
|
8
|
+
* Host ID to proxy the request to
|
|
9
|
+
*/
|
|
10
|
+
id: string;
|
|
11
|
+
/**
|
|
12
|
+
* API path to proxy
|
|
13
|
+
*/
|
|
14
|
+
path: string;
|
|
15
|
+
};
|
|
16
|
+
query?: never;
|
|
17
|
+
url: '/v1/connector/consoles/{id}/*path';
|
|
18
|
+
};
|
|
19
|
+
export type ConnectorDeleteErrors = {
|
|
20
|
+
/**
|
|
21
|
+
* 400
|
|
22
|
+
*/
|
|
23
|
+
400: {
|
|
24
|
+
/**
|
|
25
|
+
* Error code from upstream
|
|
26
|
+
*/
|
|
27
|
+
code?: unknown;
|
|
28
|
+
/**
|
|
29
|
+
* HTTP status code
|
|
30
|
+
*/
|
|
31
|
+
httpStatusCode?: number;
|
|
32
|
+
/**
|
|
33
|
+
* Error message
|
|
34
|
+
*/
|
|
35
|
+
message?: string;
|
|
36
|
+
/**
|
|
37
|
+
* Request trace identifier
|
|
38
|
+
*/
|
|
39
|
+
traceId?: string;
|
|
40
|
+
};
|
|
41
|
+
/**
|
|
42
|
+
* 401
|
|
43
|
+
*/
|
|
44
|
+
401: {
|
|
45
|
+
/**
|
|
46
|
+
* Error code from upstream
|
|
47
|
+
*/
|
|
48
|
+
code?: unknown;
|
|
49
|
+
/**
|
|
50
|
+
* HTTP status code
|
|
51
|
+
*/
|
|
52
|
+
httpStatusCode?: number;
|
|
53
|
+
/**
|
|
54
|
+
* Error message
|
|
55
|
+
*/
|
|
56
|
+
message?: string;
|
|
57
|
+
/**
|
|
58
|
+
* Request trace identifier
|
|
59
|
+
*/
|
|
60
|
+
traceId?: string;
|
|
61
|
+
};
|
|
62
|
+
/**
|
|
63
|
+
* 403
|
|
64
|
+
*/
|
|
65
|
+
403: {
|
|
66
|
+
/**
|
|
67
|
+
* Error code from upstream
|
|
68
|
+
*/
|
|
69
|
+
code?: unknown;
|
|
70
|
+
/**
|
|
71
|
+
* HTTP status code
|
|
72
|
+
*/
|
|
73
|
+
httpStatusCode?: number;
|
|
74
|
+
/**
|
|
75
|
+
* Error message
|
|
76
|
+
*/
|
|
77
|
+
message?: string;
|
|
78
|
+
/**
|
|
79
|
+
* Request trace identifier
|
|
80
|
+
*/
|
|
81
|
+
traceId?: string;
|
|
82
|
+
};
|
|
83
|
+
/**
|
|
84
|
+
* 408
|
|
85
|
+
*/
|
|
86
|
+
408: {
|
|
87
|
+
/**
|
|
88
|
+
* Error code from upstream
|
|
89
|
+
*/
|
|
90
|
+
code?: unknown;
|
|
91
|
+
/**
|
|
92
|
+
* HTTP status code
|
|
93
|
+
*/
|
|
94
|
+
httpStatusCode?: number;
|
|
95
|
+
/**
|
|
96
|
+
* Error message
|
|
97
|
+
*/
|
|
98
|
+
message?: string;
|
|
99
|
+
/**
|
|
100
|
+
* Request trace identifier
|
|
101
|
+
*/
|
|
102
|
+
traceId?: string;
|
|
103
|
+
};
|
|
104
|
+
/**
|
|
105
|
+
* 429
|
|
106
|
+
*/
|
|
107
|
+
429: {
|
|
108
|
+
/**
|
|
109
|
+
* Error code from upstream
|
|
110
|
+
*/
|
|
111
|
+
code?: unknown;
|
|
112
|
+
/**
|
|
113
|
+
* HTTP status code
|
|
114
|
+
*/
|
|
115
|
+
httpStatusCode?: number;
|
|
116
|
+
/**
|
|
117
|
+
* Error message
|
|
118
|
+
*/
|
|
119
|
+
message?: string;
|
|
120
|
+
/**
|
|
121
|
+
* Request trace identifier
|
|
122
|
+
*/
|
|
123
|
+
traceId?: string;
|
|
124
|
+
};
|
|
125
|
+
/**
|
|
126
|
+
* 500
|
|
127
|
+
*/
|
|
128
|
+
500: {
|
|
129
|
+
/**
|
|
130
|
+
* Error code from upstream
|
|
131
|
+
*/
|
|
132
|
+
code?: unknown;
|
|
133
|
+
/**
|
|
134
|
+
* HTTP status code
|
|
135
|
+
*/
|
|
136
|
+
httpStatusCode?: number;
|
|
137
|
+
/**
|
|
138
|
+
* Error message
|
|
139
|
+
*/
|
|
140
|
+
message?: string;
|
|
141
|
+
/**
|
|
142
|
+
* Request trace identifier
|
|
143
|
+
*/
|
|
144
|
+
traceId?: string;
|
|
145
|
+
};
|
|
146
|
+
/**
|
|
147
|
+
* 502
|
|
148
|
+
*/
|
|
149
|
+
502: {
|
|
150
|
+
/**
|
|
151
|
+
* Error code from upstream
|
|
152
|
+
*/
|
|
153
|
+
code?: unknown;
|
|
154
|
+
/**
|
|
155
|
+
* HTTP status code
|
|
156
|
+
*/
|
|
157
|
+
httpStatusCode?: number;
|
|
158
|
+
/**
|
|
159
|
+
* Error message
|
|
160
|
+
*/
|
|
161
|
+
message?: string;
|
|
162
|
+
/**
|
|
163
|
+
* Request trace identifier
|
|
164
|
+
*/
|
|
165
|
+
traceId?: string;
|
|
166
|
+
};
|
|
167
|
+
};
|
|
168
|
+
export type ConnectorDeleteError = ConnectorDeleteErrors[keyof ConnectorDeleteErrors];
|
|
169
|
+
export type ConnectorDeleteResponses = {
|
|
170
|
+
/**
|
|
171
|
+
* 200
|
|
172
|
+
*/
|
|
173
|
+
200: {
|
|
174
|
+
[key: string]: unknown;
|
|
175
|
+
};
|
|
176
|
+
};
|
|
177
|
+
export type ConnectorDeleteResponse = ConnectorDeleteResponses[keyof ConnectorDeleteResponses];
|
|
178
|
+
export type ConnectorGetData = {
|
|
179
|
+
body?: never;
|
|
180
|
+
path: {
|
|
181
|
+
/**
|
|
182
|
+
* Host ID to proxy the request to
|
|
183
|
+
*/
|
|
184
|
+
id: string;
|
|
185
|
+
/**
|
|
186
|
+
* API path to proxy
|
|
187
|
+
*/
|
|
188
|
+
path: string;
|
|
189
|
+
};
|
|
190
|
+
query?: never;
|
|
191
|
+
url: '/v1/connector/consoles/{id}/*path';
|
|
192
|
+
};
|
|
193
|
+
export type ConnectorGetErrors = {
|
|
194
|
+
/**
|
|
195
|
+
* 400
|
|
196
|
+
*/
|
|
197
|
+
400: {
|
|
198
|
+
/**
|
|
199
|
+
* Error code from upstream
|
|
200
|
+
*/
|
|
201
|
+
code?: unknown;
|
|
202
|
+
/**
|
|
203
|
+
* HTTP status code
|
|
204
|
+
*/
|
|
205
|
+
httpStatusCode?: number;
|
|
206
|
+
/**
|
|
207
|
+
* Error message
|
|
208
|
+
*/
|
|
209
|
+
message?: string;
|
|
210
|
+
/**
|
|
211
|
+
* Request trace identifier
|
|
212
|
+
*/
|
|
213
|
+
traceId?: string;
|
|
214
|
+
};
|
|
215
|
+
/**
|
|
216
|
+
* 401
|
|
217
|
+
*/
|
|
218
|
+
401: {
|
|
219
|
+
/**
|
|
220
|
+
* Error code from upstream
|
|
221
|
+
*/
|
|
222
|
+
code?: unknown;
|
|
223
|
+
/**
|
|
224
|
+
* HTTP status code
|
|
225
|
+
*/
|
|
226
|
+
httpStatusCode?: number;
|
|
227
|
+
/**
|
|
228
|
+
* Error message
|
|
229
|
+
*/
|
|
230
|
+
message?: string;
|
|
231
|
+
/**
|
|
232
|
+
* Request trace identifier
|
|
233
|
+
*/
|
|
234
|
+
traceId?: string;
|
|
235
|
+
};
|
|
236
|
+
/**
|
|
237
|
+
* 403
|
|
238
|
+
*/
|
|
239
|
+
403: {
|
|
240
|
+
/**
|
|
241
|
+
* Error code from upstream
|
|
242
|
+
*/
|
|
243
|
+
code?: unknown;
|
|
244
|
+
/**
|
|
245
|
+
* HTTP status code
|
|
246
|
+
*/
|
|
247
|
+
httpStatusCode?: number;
|
|
248
|
+
/**
|
|
249
|
+
* Error message
|
|
250
|
+
*/
|
|
251
|
+
message?: string;
|
|
252
|
+
/**
|
|
253
|
+
* Request trace identifier
|
|
254
|
+
*/
|
|
255
|
+
traceId?: string;
|
|
256
|
+
};
|
|
257
|
+
/**
|
|
258
|
+
* 408
|
|
259
|
+
*/
|
|
260
|
+
408: {
|
|
261
|
+
/**
|
|
262
|
+
* Error code from upstream
|
|
263
|
+
*/
|
|
264
|
+
code?: unknown;
|
|
265
|
+
/**
|
|
266
|
+
* HTTP status code
|
|
267
|
+
*/
|
|
268
|
+
httpStatusCode?: number;
|
|
269
|
+
/**
|
|
270
|
+
* Error message
|
|
271
|
+
*/
|
|
272
|
+
message?: string;
|
|
273
|
+
/**
|
|
274
|
+
* Request trace identifier
|
|
275
|
+
*/
|
|
276
|
+
traceId?: string;
|
|
277
|
+
};
|
|
278
|
+
/**
|
|
279
|
+
* 429
|
|
280
|
+
*/
|
|
281
|
+
429: {
|
|
282
|
+
/**
|
|
283
|
+
* Error code from upstream
|
|
284
|
+
*/
|
|
285
|
+
code?: unknown;
|
|
286
|
+
/**
|
|
287
|
+
* HTTP status code
|
|
288
|
+
*/
|
|
289
|
+
httpStatusCode?: number;
|
|
290
|
+
/**
|
|
291
|
+
* Error message
|
|
292
|
+
*/
|
|
293
|
+
message?: string;
|
|
294
|
+
/**
|
|
295
|
+
* Request trace identifier
|
|
296
|
+
*/
|
|
297
|
+
traceId?: string;
|
|
298
|
+
};
|
|
299
|
+
/**
|
|
300
|
+
* 500
|
|
301
|
+
*/
|
|
302
|
+
500: {
|
|
303
|
+
/**
|
|
304
|
+
* Error code from upstream
|
|
305
|
+
*/
|
|
306
|
+
code?: unknown;
|
|
307
|
+
/**
|
|
308
|
+
* HTTP status code
|
|
309
|
+
*/
|
|
310
|
+
httpStatusCode?: number;
|
|
311
|
+
/**
|
|
312
|
+
* Error message
|
|
313
|
+
*/
|
|
314
|
+
message?: string;
|
|
315
|
+
/**
|
|
316
|
+
* Request trace identifier
|
|
317
|
+
*/
|
|
318
|
+
traceId?: string;
|
|
319
|
+
};
|
|
320
|
+
/**
|
|
321
|
+
* 502
|
|
322
|
+
*/
|
|
323
|
+
502: {
|
|
324
|
+
/**
|
|
325
|
+
* Error code from upstream
|
|
326
|
+
*/
|
|
327
|
+
code?: unknown;
|
|
328
|
+
/**
|
|
329
|
+
* HTTP status code
|
|
330
|
+
*/
|
|
331
|
+
httpStatusCode?: number;
|
|
332
|
+
/**
|
|
333
|
+
* Error message
|
|
334
|
+
*/
|
|
335
|
+
message?: string;
|
|
336
|
+
/**
|
|
337
|
+
* Request trace identifier
|
|
338
|
+
*/
|
|
339
|
+
traceId?: string;
|
|
340
|
+
};
|
|
341
|
+
};
|
|
342
|
+
export type ConnectorGetError = ConnectorGetErrors[keyof ConnectorGetErrors];
|
|
343
|
+
export type ConnectorGetResponses = {
|
|
344
|
+
/**
|
|
345
|
+
* 200
|
|
346
|
+
*/
|
|
347
|
+
200: {
|
|
348
|
+
[key: string]: unknown;
|
|
349
|
+
};
|
|
350
|
+
};
|
|
351
|
+
export type ConnectorGetResponse = ConnectorGetResponses[keyof ConnectorGetResponses];
|
|
352
|
+
export type ConnectorPatchData = {
|
|
353
|
+
body?: {
|
|
354
|
+
[key: string]: unknown;
|
|
355
|
+
};
|
|
356
|
+
path: {
|
|
357
|
+
/**
|
|
358
|
+
* Host ID to proxy the request to
|
|
359
|
+
*/
|
|
360
|
+
id: string;
|
|
361
|
+
/**
|
|
362
|
+
* API path to proxy
|
|
363
|
+
*/
|
|
364
|
+
path: string;
|
|
365
|
+
};
|
|
366
|
+
query?: never;
|
|
367
|
+
url: '/v1/connector/consoles/{id}/*path';
|
|
368
|
+
};
|
|
369
|
+
export type ConnectorPatchErrors = {
|
|
370
|
+
/**
|
|
371
|
+
* 400
|
|
372
|
+
*/
|
|
373
|
+
400: {
|
|
374
|
+
/**
|
|
375
|
+
* Error code from upstream
|
|
376
|
+
*/
|
|
377
|
+
code?: unknown;
|
|
378
|
+
/**
|
|
379
|
+
* HTTP status code
|
|
380
|
+
*/
|
|
381
|
+
httpStatusCode?: number;
|
|
382
|
+
/**
|
|
383
|
+
* Error message
|
|
384
|
+
*/
|
|
385
|
+
message?: string;
|
|
386
|
+
/**
|
|
387
|
+
* Request trace identifier
|
|
388
|
+
*/
|
|
389
|
+
traceId?: string;
|
|
390
|
+
};
|
|
391
|
+
/**
|
|
392
|
+
* 401
|
|
393
|
+
*/
|
|
394
|
+
401: {
|
|
395
|
+
/**
|
|
396
|
+
* Error code from upstream
|
|
397
|
+
*/
|
|
398
|
+
code?: unknown;
|
|
399
|
+
/**
|
|
400
|
+
* HTTP status code
|
|
401
|
+
*/
|
|
402
|
+
httpStatusCode?: number;
|
|
403
|
+
/**
|
|
404
|
+
* Error message
|
|
405
|
+
*/
|
|
406
|
+
message?: string;
|
|
407
|
+
/**
|
|
408
|
+
* Request trace identifier
|
|
409
|
+
*/
|
|
410
|
+
traceId?: string;
|
|
411
|
+
};
|
|
412
|
+
/**
|
|
413
|
+
* 403
|
|
414
|
+
*/
|
|
415
|
+
403: {
|
|
416
|
+
/**
|
|
417
|
+
* Error code from upstream
|
|
418
|
+
*/
|
|
419
|
+
code?: unknown;
|
|
420
|
+
/**
|
|
421
|
+
* HTTP status code
|
|
422
|
+
*/
|
|
423
|
+
httpStatusCode?: number;
|
|
424
|
+
/**
|
|
425
|
+
* Error message
|
|
426
|
+
*/
|
|
427
|
+
message?: string;
|
|
428
|
+
/**
|
|
429
|
+
* Request trace identifier
|
|
430
|
+
*/
|
|
431
|
+
traceId?: string;
|
|
432
|
+
};
|
|
433
|
+
/**
|
|
434
|
+
* 408
|
|
435
|
+
*/
|
|
436
|
+
408: {
|
|
437
|
+
/**
|
|
438
|
+
* Error code from upstream
|
|
439
|
+
*/
|
|
440
|
+
code?: unknown;
|
|
441
|
+
/**
|
|
442
|
+
* HTTP status code
|
|
443
|
+
*/
|
|
444
|
+
httpStatusCode?: number;
|
|
445
|
+
/**
|
|
446
|
+
* Error message
|
|
447
|
+
*/
|
|
448
|
+
message?: string;
|
|
449
|
+
/**
|
|
450
|
+
* Request trace identifier
|
|
451
|
+
*/
|
|
452
|
+
traceId?: string;
|
|
453
|
+
};
|
|
454
|
+
/**
|
|
455
|
+
* 429
|
|
456
|
+
*/
|
|
457
|
+
429: {
|
|
458
|
+
/**
|
|
459
|
+
* Error code from upstream
|
|
460
|
+
*/
|
|
461
|
+
code?: unknown;
|
|
462
|
+
/**
|
|
463
|
+
* HTTP status code
|
|
464
|
+
*/
|
|
465
|
+
httpStatusCode?: number;
|
|
466
|
+
/**
|
|
467
|
+
* Error message
|
|
468
|
+
*/
|
|
469
|
+
message?: string;
|
|
470
|
+
/**
|
|
471
|
+
* Request trace identifier
|
|
472
|
+
*/
|
|
473
|
+
traceId?: string;
|
|
474
|
+
};
|
|
475
|
+
/**
|
|
476
|
+
* 500
|
|
477
|
+
*/
|
|
478
|
+
500: {
|
|
479
|
+
/**
|
|
480
|
+
* Error code from upstream
|
|
481
|
+
*/
|
|
482
|
+
code?: unknown;
|
|
483
|
+
/**
|
|
484
|
+
* HTTP status code
|
|
485
|
+
*/
|
|
486
|
+
httpStatusCode?: number;
|
|
487
|
+
/**
|
|
488
|
+
* Error message
|
|
489
|
+
*/
|
|
490
|
+
message?: string;
|
|
491
|
+
/**
|
|
492
|
+
* Request trace identifier
|
|
493
|
+
*/
|
|
494
|
+
traceId?: string;
|
|
495
|
+
};
|
|
496
|
+
/**
|
|
497
|
+
* 502
|
|
498
|
+
*/
|
|
499
|
+
502: {
|
|
500
|
+
/**
|
|
501
|
+
* Error code from upstream
|
|
502
|
+
*/
|
|
503
|
+
code?: unknown;
|
|
504
|
+
/**
|
|
505
|
+
* HTTP status code
|
|
506
|
+
*/
|
|
507
|
+
httpStatusCode?: number;
|
|
508
|
+
/**
|
|
509
|
+
* Error message
|
|
510
|
+
*/
|
|
511
|
+
message?: string;
|
|
512
|
+
/**
|
|
513
|
+
* Request trace identifier
|
|
514
|
+
*/
|
|
515
|
+
traceId?: string;
|
|
516
|
+
};
|
|
517
|
+
};
|
|
518
|
+
export type ConnectorPatchError = ConnectorPatchErrors[keyof ConnectorPatchErrors];
|
|
519
|
+
export type ConnectorPatchResponses = {
|
|
520
|
+
/**
|
|
521
|
+
* 200
|
|
522
|
+
*/
|
|
523
|
+
200: {
|
|
524
|
+
[key: string]: unknown;
|
|
525
|
+
};
|
|
526
|
+
};
|
|
527
|
+
export type ConnectorPatchResponse = ConnectorPatchResponses[keyof ConnectorPatchResponses];
|
|
528
|
+
export type ConnectorPostData = {
|
|
529
|
+
body?: {
|
|
530
|
+
[key: string]: unknown;
|
|
531
|
+
};
|
|
532
|
+
path: {
|
|
533
|
+
/**
|
|
534
|
+
* Host ID to proxy the request to
|
|
535
|
+
*/
|
|
536
|
+
id: string;
|
|
537
|
+
/**
|
|
538
|
+
* API path to proxy
|
|
539
|
+
*/
|
|
540
|
+
path: string;
|
|
541
|
+
};
|
|
542
|
+
query?: never;
|
|
543
|
+
url: '/v1/connector/consoles/{id}/*path';
|
|
544
|
+
};
|
|
545
|
+
export type ConnectorPostErrors = {
|
|
546
|
+
/**
|
|
547
|
+
* 400
|
|
548
|
+
*/
|
|
549
|
+
400: {
|
|
550
|
+
/**
|
|
551
|
+
* Error code from upstream
|
|
552
|
+
*/
|
|
553
|
+
code?: unknown;
|
|
554
|
+
/**
|
|
555
|
+
* HTTP status code
|
|
556
|
+
*/
|
|
557
|
+
httpStatusCode?: number;
|
|
558
|
+
/**
|
|
559
|
+
* Error message
|
|
560
|
+
*/
|
|
561
|
+
message?: string;
|
|
562
|
+
/**
|
|
563
|
+
* Request trace identifier
|
|
564
|
+
*/
|
|
565
|
+
traceId?: string;
|
|
566
|
+
};
|
|
567
|
+
/**
|
|
568
|
+
* 401
|
|
569
|
+
*/
|
|
570
|
+
401: {
|
|
571
|
+
/**
|
|
572
|
+
* Error code from upstream
|
|
573
|
+
*/
|
|
574
|
+
code?: unknown;
|
|
575
|
+
/**
|
|
576
|
+
* HTTP status code
|
|
577
|
+
*/
|
|
578
|
+
httpStatusCode?: number;
|
|
579
|
+
/**
|
|
580
|
+
* Error message
|
|
581
|
+
*/
|
|
582
|
+
message?: string;
|
|
583
|
+
/**
|
|
584
|
+
* Request trace identifier
|
|
585
|
+
*/
|
|
586
|
+
traceId?: string;
|
|
587
|
+
};
|
|
588
|
+
/**
|
|
589
|
+
* 403
|
|
590
|
+
*/
|
|
591
|
+
403: {
|
|
592
|
+
/**
|
|
593
|
+
* Error code from upstream
|
|
594
|
+
*/
|
|
595
|
+
code?: unknown;
|
|
596
|
+
/**
|
|
597
|
+
* HTTP status code
|
|
598
|
+
*/
|
|
599
|
+
httpStatusCode?: number;
|
|
600
|
+
/**
|
|
601
|
+
* Error message
|
|
602
|
+
*/
|
|
603
|
+
message?: string;
|
|
604
|
+
/**
|
|
605
|
+
* Request trace identifier
|
|
606
|
+
*/
|
|
607
|
+
traceId?: string;
|
|
608
|
+
};
|
|
609
|
+
/**
|
|
610
|
+
* 408
|
|
611
|
+
*/
|
|
612
|
+
408: {
|
|
613
|
+
/**
|
|
614
|
+
* Error code from upstream
|
|
615
|
+
*/
|
|
616
|
+
code?: unknown;
|
|
617
|
+
/**
|
|
618
|
+
* HTTP status code
|
|
619
|
+
*/
|
|
620
|
+
httpStatusCode?: number;
|
|
621
|
+
/**
|
|
622
|
+
* Error message
|
|
623
|
+
*/
|
|
624
|
+
message?: string;
|
|
625
|
+
/**
|
|
626
|
+
* Request trace identifier
|
|
627
|
+
*/
|
|
628
|
+
traceId?: string;
|
|
629
|
+
};
|
|
630
|
+
/**
|
|
631
|
+
* 429
|
|
632
|
+
*/
|
|
633
|
+
429: {
|
|
634
|
+
/**
|
|
635
|
+
* Error code from upstream
|
|
636
|
+
*/
|
|
637
|
+
code?: unknown;
|
|
638
|
+
/**
|
|
639
|
+
* HTTP status code
|
|
640
|
+
*/
|
|
641
|
+
httpStatusCode?: number;
|
|
642
|
+
/**
|
|
643
|
+
* Error message
|
|
644
|
+
*/
|
|
645
|
+
message?: string;
|
|
646
|
+
/**
|
|
647
|
+
* Request trace identifier
|
|
648
|
+
*/
|
|
649
|
+
traceId?: string;
|
|
650
|
+
};
|
|
651
|
+
/**
|
|
652
|
+
* 500
|
|
653
|
+
*/
|
|
654
|
+
500: {
|
|
655
|
+
/**
|
|
656
|
+
* Error code from upstream
|
|
657
|
+
*/
|
|
658
|
+
code?: unknown;
|
|
659
|
+
/**
|
|
660
|
+
* HTTP status code
|
|
661
|
+
*/
|
|
662
|
+
httpStatusCode?: number;
|
|
663
|
+
/**
|
|
664
|
+
* Error message
|
|
665
|
+
*/
|
|
666
|
+
message?: string;
|
|
667
|
+
/**
|
|
668
|
+
* Request trace identifier
|
|
669
|
+
*/
|
|
670
|
+
traceId?: string;
|
|
671
|
+
};
|
|
672
|
+
/**
|
|
673
|
+
* 502
|
|
674
|
+
*/
|
|
675
|
+
502: {
|
|
676
|
+
/**
|
|
677
|
+
* Error code from upstream
|
|
678
|
+
*/
|
|
679
|
+
code?: unknown;
|
|
680
|
+
/**
|
|
681
|
+
* HTTP status code
|
|
682
|
+
*/
|
|
683
|
+
httpStatusCode?: number;
|
|
684
|
+
/**
|
|
685
|
+
* Error message
|
|
686
|
+
*/
|
|
687
|
+
message?: string;
|
|
688
|
+
/**
|
|
689
|
+
* Request trace identifier
|
|
690
|
+
*/
|
|
691
|
+
traceId?: string;
|
|
692
|
+
};
|
|
693
|
+
};
|
|
694
|
+
export type ConnectorPostError = ConnectorPostErrors[keyof ConnectorPostErrors];
|
|
695
|
+
export type ConnectorPostResponses = {
|
|
696
|
+
/**
|
|
697
|
+
* 200
|
|
698
|
+
*/
|
|
699
|
+
200: {
|
|
700
|
+
[key: string]: unknown;
|
|
701
|
+
};
|
|
702
|
+
};
|
|
703
|
+
export type ConnectorPostResponse = ConnectorPostResponses[keyof ConnectorPostResponses];
|
|
704
|
+
export type ConnectorPutData = {
|
|
705
|
+
body?: {
|
|
706
|
+
[key: string]: unknown;
|
|
707
|
+
};
|
|
708
|
+
path: {
|
|
709
|
+
/**
|
|
710
|
+
* Host ID to proxy the request to
|
|
711
|
+
*/
|
|
712
|
+
id: string;
|
|
713
|
+
/**
|
|
714
|
+
* API path to proxy
|
|
715
|
+
*/
|
|
716
|
+
path: string;
|
|
717
|
+
};
|
|
718
|
+
query?: never;
|
|
719
|
+
url: '/v1/connector/consoles/{id}/*path';
|
|
720
|
+
};
|
|
721
|
+
export type ConnectorPutErrors = {
|
|
722
|
+
/**
|
|
723
|
+
* 400
|
|
724
|
+
*/
|
|
725
|
+
400: {
|
|
726
|
+
/**
|
|
727
|
+
* Error code from upstream
|
|
728
|
+
*/
|
|
729
|
+
code?: unknown;
|
|
730
|
+
/**
|
|
731
|
+
* HTTP status code
|
|
732
|
+
*/
|
|
733
|
+
httpStatusCode?: number;
|
|
734
|
+
/**
|
|
735
|
+
* Error message
|
|
736
|
+
*/
|
|
737
|
+
message?: string;
|
|
738
|
+
/**
|
|
739
|
+
* Request trace identifier
|
|
740
|
+
*/
|
|
741
|
+
traceId?: string;
|
|
742
|
+
};
|
|
743
|
+
/**
|
|
744
|
+
* 401
|
|
745
|
+
*/
|
|
746
|
+
401: {
|
|
747
|
+
/**
|
|
748
|
+
* Error code from upstream
|
|
749
|
+
*/
|
|
750
|
+
code?: unknown;
|
|
751
|
+
/**
|
|
752
|
+
* HTTP status code
|
|
753
|
+
*/
|
|
754
|
+
httpStatusCode?: number;
|
|
755
|
+
/**
|
|
756
|
+
* Error message
|
|
757
|
+
*/
|
|
758
|
+
message?: string;
|
|
759
|
+
/**
|
|
760
|
+
* Request trace identifier
|
|
761
|
+
*/
|
|
762
|
+
traceId?: string;
|
|
763
|
+
};
|
|
764
|
+
/**
|
|
765
|
+
* 403
|
|
766
|
+
*/
|
|
767
|
+
403: {
|
|
768
|
+
/**
|
|
769
|
+
* Error code from upstream
|
|
770
|
+
*/
|
|
771
|
+
code?: unknown;
|
|
772
|
+
/**
|
|
773
|
+
* HTTP status code
|
|
774
|
+
*/
|
|
775
|
+
httpStatusCode?: number;
|
|
776
|
+
/**
|
|
777
|
+
* Error message
|
|
778
|
+
*/
|
|
779
|
+
message?: string;
|
|
780
|
+
/**
|
|
781
|
+
* Request trace identifier
|
|
782
|
+
*/
|
|
783
|
+
traceId?: string;
|
|
784
|
+
};
|
|
785
|
+
/**
|
|
786
|
+
* 408
|
|
787
|
+
*/
|
|
788
|
+
408: {
|
|
789
|
+
/**
|
|
790
|
+
* Error code from upstream
|
|
791
|
+
*/
|
|
792
|
+
code?: unknown;
|
|
793
|
+
/**
|
|
794
|
+
* HTTP status code
|
|
795
|
+
*/
|
|
796
|
+
httpStatusCode?: number;
|
|
797
|
+
/**
|
|
798
|
+
* Error message
|
|
799
|
+
*/
|
|
800
|
+
message?: string;
|
|
801
|
+
/**
|
|
802
|
+
* Request trace identifier
|
|
803
|
+
*/
|
|
804
|
+
traceId?: string;
|
|
805
|
+
};
|
|
806
|
+
/**
|
|
807
|
+
* 429
|
|
808
|
+
*/
|
|
809
|
+
429: {
|
|
810
|
+
/**
|
|
811
|
+
* Error code from upstream
|
|
812
|
+
*/
|
|
813
|
+
code?: unknown;
|
|
814
|
+
/**
|
|
815
|
+
* HTTP status code
|
|
816
|
+
*/
|
|
817
|
+
httpStatusCode?: number;
|
|
818
|
+
/**
|
|
819
|
+
* Error message
|
|
820
|
+
*/
|
|
821
|
+
message?: string;
|
|
822
|
+
/**
|
|
823
|
+
* Request trace identifier
|
|
824
|
+
*/
|
|
825
|
+
traceId?: string;
|
|
826
|
+
};
|
|
827
|
+
/**
|
|
828
|
+
* 500
|
|
829
|
+
*/
|
|
830
|
+
500: {
|
|
831
|
+
/**
|
|
832
|
+
* Error code from upstream
|
|
833
|
+
*/
|
|
834
|
+
code?: unknown;
|
|
835
|
+
/**
|
|
836
|
+
* HTTP status code
|
|
837
|
+
*/
|
|
838
|
+
httpStatusCode?: number;
|
|
839
|
+
/**
|
|
840
|
+
* Error message
|
|
841
|
+
*/
|
|
842
|
+
message?: string;
|
|
843
|
+
/**
|
|
844
|
+
* Request trace identifier
|
|
845
|
+
*/
|
|
846
|
+
traceId?: string;
|
|
847
|
+
};
|
|
848
|
+
/**
|
|
849
|
+
* 502
|
|
850
|
+
*/
|
|
851
|
+
502: {
|
|
852
|
+
/**
|
|
853
|
+
* Error code from upstream
|
|
854
|
+
*/
|
|
855
|
+
code?: unknown;
|
|
856
|
+
/**
|
|
857
|
+
* HTTP status code
|
|
858
|
+
*/
|
|
859
|
+
httpStatusCode?: number;
|
|
860
|
+
/**
|
|
861
|
+
* Error message
|
|
862
|
+
*/
|
|
863
|
+
message?: string;
|
|
864
|
+
/**
|
|
865
|
+
* Request trace identifier
|
|
866
|
+
*/
|
|
867
|
+
traceId?: string;
|
|
868
|
+
};
|
|
869
|
+
};
|
|
870
|
+
export type ConnectorPutError = ConnectorPutErrors[keyof ConnectorPutErrors];
|
|
871
|
+
export type ConnectorPutResponses = {
|
|
872
|
+
/**
|
|
873
|
+
* 200
|
|
874
|
+
*/
|
|
875
|
+
200: {
|
|
876
|
+
[key: string]: unknown;
|
|
877
|
+
};
|
|
878
|
+
};
|
|
879
|
+
export type ConnectorPutResponse = ConnectorPutResponses[keyof ConnectorPutResponses];
|
|
880
|
+
export type ListDevicesData = {
|
|
881
|
+
body?: never;
|
|
882
|
+
path?: never;
|
|
883
|
+
query?: {
|
|
884
|
+
/**
|
|
885
|
+
* List of host IDs to filter the results
|
|
886
|
+
*/
|
|
887
|
+
'hostIds[]'?: Array<string>;
|
|
888
|
+
/**
|
|
889
|
+
* Last processed timestamp of devices in RFC3339 format
|
|
890
|
+
*/
|
|
891
|
+
time?: string;
|
|
892
|
+
/**
|
|
893
|
+
* Number of items to return per page
|
|
894
|
+
*/
|
|
895
|
+
pageSize?: string;
|
|
896
|
+
/**
|
|
897
|
+
* Token for pagination to retrieve the next set of results
|
|
898
|
+
*/
|
|
899
|
+
nextToken?: string;
|
|
900
|
+
};
|
|
901
|
+
url: '/v1/devices';
|
|
902
|
+
};
|
|
903
|
+
export type ListDevicesErrors = {
|
|
904
|
+
/**
|
|
905
|
+
* 400
|
|
906
|
+
*/
|
|
907
|
+
400: {
|
|
908
|
+
/**
|
|
909
|
+
* Error code from upstream
|
|
910
|
+
*/
|
|
911
|
+
code?: unknown;
|
|
912
|
+
/**
|
|
913
|
+
* HTTP status code
|
|
914
|
+
*/
|
|
915
|
+
httpStatusCode?: number;
|
|
916
|
+
/**
|
|
917
|
+
* Error message
|
|
918
|
+
*/
|
|
919
|
+
message?: string;
|
|
920
|
+
/**
|
|
921
|
+
* Request trace identifier
|
|
922
|
+
*/
|
|
923
|
+
traceId?: string;
|
|
924
|
+
};
|
|
925
|
+
/**
|
|
926
|
+
* 401
|
|
927
|
+
*/
|
|
928
|
+
401: {
|
|
929
|
+
/**
|
|
930
|
+
* Error code from upstream
|
|
931
|
+
*/
|
|
932
|
+
code?: unknown;
|
|
933
|
+
/**
|
|
934
|
+
* HTTP status code
|
|
935
|
+
*/
|
|
936
|
+
httpStatusCode?: number;
|
|
937
|
+
/**
|
|
938
|
+
* Error message
|
|
939
|
+
*/
|
|
940
|
+
message?: string;
|
|
941
|
+
/**
|
|
942
|
+
* Request trace identifier
|
|
943
|
+
*/
|
|
944
|
+
traceId?: string;
|
|
945
|
+
};
|
|
946
|
+
/**
|
|
947
|
+
* 429
|
|
948
|
+
*/
|
|
949
|
+
429: {
|
|
950
|
+
/**
|
|
951
|
+
* Error code from upstream
|
|
952
|
+
*/
|
|
953
|
+
code?: unknown;
|
|
954
|
+
/**
|
|
955
|
+
* HTTP status code
|
|
956
|
+
*/
|
|
957
|
+
httpStatusCode?: number;
|
|
958
|
+
/**
|
|
959
|
+
* Error message
|
|
960
|
+
*/
|
|
961
|
+
message?: string;
|
|
962
|
+
/**
|
|
963
|
+
* Request trace identifier
|
|
964
|
+
*/
|
|
965
|
+
traceId?: string;
|
|
966
|
+
};
|
|
967
|
+
/**
|
|
968
|
+
* 500
|
|
969
|
+
*/
|
|
970
|
+
500: {
|
|
971
|
+
/**
|
|
972
|
+
* Error code from upstream
|
|
973
|
+
*/
|
|
974
|
+
code?: unknown;
|
|
975
|
+
/**
|
|
976
|
+
* HTTP status code
|
|
977
|
+
*/
|
|
978
|
+
httpStatusCode?: number;
|
|
979
|
+
/**
|
|
980
|
+
* Error message
|
|
981
|
+
*/
|
|
982
|
+
message?: string;
|
|
983
|
+
/**
|
|
984
|
+
* Request trace identifier
|
|
985
|
+
*/
|
|
986
|
+
traceId?: string;
|
|
987
|
+
};
|
|
988
|
+
/**
|
|
989
|
+
* 502
|
|
990
|
+
*/
|
|
991
|
+
502: {
|
|
992
|
+
/**
|
|
993
|
+
* Error code from upstream
|
|
994
|
+
*/
|
|
995
|
+
code?: unknown;
|
|
996
|
+
/**
|
|
997
|
+
* HTTP status code
|
|
998
|
+
*/
|
|
999
|
+
httpStatusCode?: number;
|
|
1000
|
+
/**
|
|
1001
|
+
* Error message
|
|
1002
|
+
*/
|
|
1003
|
+
message?: string;
|
|
1004
|
+
/**
|
|
1005
|
+
* Request trace identifier
|
|
1006
|
+
*/
|
|
1007
|
+
traceId?: string;
|
|
1008
|
+
};
|
|
1009
|
+
};
|
|
1010
|
+
export type ListDevicesError = ListDevicesErrors[keyof ListDevicesErrors];
|
|
1011
|
+
export type ListDevicesResponses = {
|
|
1012
|
+
/**
|
|
1013
|
+
* 200
|
|
1014
|
+
*/
|
|
1015
|
+
200: {
|
|
1016
|
+
/**
|
|
1017
|
+
* Error code from upstream
|
|
1018
|
+
*/
|
|
1019
|
+
code?: unknown;
|
|
1020
|
+
/**
|
|
1021
|
+
* Generic response data, specific schema depends on the endpoint
|
|
1022
|
+
*/
|
|
1023
|
+
data?: Array<{
|
|
1024
|
+
/**
|
|
1025
|
+
* Unique identifier of the host device
|
|
1026
|
+
*/
|
|
1027
|
+
hostId?: string;
|
|
1028
|
+
/**
|
|
1029
|
+
* Name of the host device
|
|
1030
|
+
*/
|
|
1031
|
+
hostName?: string;
|
|
1032
|
+
/**
|
|
1033
|
+
* Array of devices managed by this host
|
|
1034
|
+
*/
|
|
1035
|
+
devices?: Array<{
|
|
1036
|
+
/**
|
|
1037
|
+
* Unique identifier of the device
|
|
1038
|
+
*/
|
|
1039
|
+
id?: string;
|
|
1040
|
+
/**
|
|
1041
|
+
* MAC address of the device
|
|
1042
|
+
*/
|
|
1043
|
+
mac?: string;
|
|
1044
|
+
/**
|
|
1045
|
+
* User-defined name of the device
|
|
1046
|
+
*/
|
|
1047
|
+
name?: string;
|
|
1048
|
+
/**
|
|
1049
|
+
* Model name of the device
|
|
1050
|
+
*/
|
|
1051
|
+
model?: string;
|
|
1052
|
+
/**
|
|
1053
|
+
* Short identifier of the device model (e.g., UDMPROSE)
|
|
1054
|
+
*/
|
|
1055
|
+
shortname?: string;
|
|
1056
|
+
/**
|
|
1057
|
+
* IP address of the device
|
|
1058
|
+
*/
|
|
1059
|
+
ip?: string;
|
|
1060
|
+
/**
|
|
1061
|
+
* Product line of the device (network, protect, etc.)
|
|
1062
|
+
*/
|
|
1063
|
+
productLine?: string | null;
|
|
1064
|
+
/**
|
|
1065
|
+
* Current connection status of the device (online, offline, etc.)
|
|
1066
|
+
*/
|
|
1067
|
+
status?: string;
|
|
1068
|
+
/**
|
|
1069
|
+
* Current firmware version of the device
|
|
1070
|
+
*/
|
|
1071
|
+
version?: string;
|
|
1072
|
+
/**
|
|
1073
|
+
* Status of device firmware (upToDate, updateAvailable, etc.)
|
|
1074
|
+
*/
|
|
1075
|
+
firmwareStatus?: string;
|
|
1076
|
+
/**
|
|
1077
|
+
* Version of firmware update available for the device, if any
|
|
1078
|
+
*/
|
|
1079
|
+
updateAvailable?: string | null;
|
|
1080
|
+
/**
|
|
1081
|
+
* Indicates if the device is a console device
|
|
1082
|
+
*/
|
|
1083
|
+
isConsole?: boolean | null;
|
|
1084
|
+
/**
|
|
1085
|
+
* Indicates if the device is managed by the controller
|
|
1086
|
+
*/
|
|
1087
|
+
isManaged?: boolean | null;
|
|
1088
|
+
/**
|
|
1089
|
+
* Time when the device was last started in RFC3339 format
|
|
1090
|
+
*/
|
|
1091
|
+
startupTime?: string | null;
|
|
1092
|
+
/**
|
|
1093
|
+
* Time when the device was adopted in RFC3339 format
|
|
1094
|
+
*/
|
|
1095
|
+
adoptionTime?: string | null;
|
|
1096
|
+
/**
|
|
1097
|
+
* User-defined notes for the device
|
|
1098
|
+
*/
|
|
1099
|
+
note?: string | null;
|
|
1100
|
+
/**
|
|
1101
|
+
* UI-specific metadata including images and identifiers
|
|
1102
|
+
*/
|
|
1103
|
+
uidb?: unknown;
|
|
1104
|
+
} | null>;
|
|
1105
|
+
/**
|
|
1106
|
+
* Last update time in RFC3339 format
|
|
1107
|
+
*/
|
|
1108
|
+
updatedAt?: string;
|
|
1109
|
+
} | null>;
|
|
1110
|
+
/**
|
|
1111
|
+
* HTTP status code
|
|
1112
|
+
*/
|
|
1113
|
+
httpStatusCode?: number;
|
|
1114
|
+
/**
|
|
1115
|
+
* Request trace identifier
|
|
1116
|
+
*/
|
|
1117
|
+
traceId?: string;
|
|
1118
|
+
/**
|
|
1119
|
+
* Pagination token for fetching the next set of results
|
|
1120
|
+
*/
|
|
1121
|
+
nextToken?: string;
|
|
1122
|
+
};
|
|
1123
|
+
};
|
|
1124
|
+
export type ListDevicesResponse = ListDevicesResponses[keyof ListDevicesResponses];
|
|
1125
|
+
export type ListHostsData = {
|
|
1126
|
+
body?: never;
|
|
1127
|
+
path?: never;
|
|
1128
|
+
query?: {
|
|
1129
|
+
/**
|
|
1130
|
+
* Number of items to return per page
|
|
1131
|
+
*/
|
|
1132
|
+
pageSize?: string;
|
|
1133
|
+
/**
|
|
1134
|
+
* Token for pagination to retrieve the next set of results
|
|
1135
|
+
*/
|
|
1136
|
+
nextToken?: string;
|
|
1137
|
+
};
|
|
1138
|
+
url: '/v1/hosts';
|
|
1139
|
+
};
|
|
1140
|
+
export type ListHostsErrors = {
|
|
1141
|
+
/**
|
|
1142
|
+
* 401
|
|
1143
|
+
*/
|
|
1144
|
+
401: {
|
|
1145
|
+
/**
|
|
1146
|
+
* Error code from upstream
|
|
1147
|
+
*/
|
|
1148
|
+
code?: unknown;
|
|
1149
|
+
/**
|
|
1150
|
+
* HTTP status code
|
|
1151
|
+
*/
|
|
1152
|
+
httpStatusCode?: number;
|
|
1153
|
+
/**
|
|
1154
|
+
* Error message
|
|
1155
|
+
*/
|
|
1156
|
+
message?: string;
|
|
1157
|
+
/**
|
|
1158
|
+
* Request trace identifier
|
|
1159
|
+
*/
|
|
1160
|
+
traceId?: string;
|
|
1161
|
+
};
|
|
1162
|
+
/**
|
|
1163
|
+
* 429
|
|
1164
|
+
*/
|
|
1165
|
+
429: {
|
|
1166
|
+
/**
|
|
1167
|
+
* Error code from upstream
|
|
1168
|
+
*/
|
|
1169
|
+
code?: unknown;
|
|
1170
|
+
/**
|
|
1171
|
+
* HTTP status code
|
|
1172
|
+
*/
|
|
1173
|
+
httpStatusCode?: number;
|
|
1174
|
+
/**
|
|
1175
|
+
* Error message
|
|
1176
|
+
*/
|
|
1177
|
+
message?: string;
|
|
1178
|
+
/**
|
|
1179
|
+
* Request trace identifier
|
|
1180
|
+
*/
|
|
1181
|
+
traceId?: string;
|
|
1182
|
+
};
|
|
1183
|
+
/**
|
|
1184
|
+
* 500
|
|
1185
|
+
*/
|
|
1186
|
+
500: {
|
|
1187
|
+
/**
|
|
1188
|
+
* Error code from upstream
|
|
1189
|
+
*/
|
|
1190
|
+
code?: unknown;
|
|
1191
|
+
/**
|
|
1192
|
+
* HTTP status code
|
|
1193
|
+
*/
|
|
1194
|
+
httpStatusCode?: number;
|
|
1195
|
+
/**
|
|
1196
|
+
* Error message
|
|
1197
|
+
*/
|
|
1198
|
+
message?: string;
|
|
1199
|
+
/**
|
|
1200
|
+
* Request trace identifier
|
|
1201
|
+
*/
|
|
1202
|
+
traceId?: string;
|
|
1203
|
+
};
|
|
1204
|
+
/**
|
|
1205
|
+
* 502
|
|
1206
|
+
*/
|
|
1207
|
+
502: {
|
|
1208
|
+
/**
|
|
1209
|
+
* Error code from upstream
|
|
1210
|
+
*/
|
|
1211
|
+
code?: unknown;
|
|
1212
|
+
/**
|
|
1213
|
+
* HTTP status code
|
|
1214
|
+
*/
|
|
1215
|
+
httpStatusCode?: number;
|
|
1216
|
+
/**
|
|
1217
|
+
* Error message
|
|
1218
|
+
*/
|
|
1219
|
+
message?: string;
|
|
1220
|
+
/**
|
|
1221
|
+
* Request trace identifier
|
|
1222
|
+
*/
|
|
1223
|
+
traceId?: string;
|
|
1224
|
+
};
|
|
1225
|
+
};
|
|
1226
|
+
export type ListHostsError = ListHostsErrors[keyof ListHostsErrors];
|
|
1227
|
+
export type ListHostsResponses = {
|
|
1228
|
+
/**
|
|
1229
|
+
* 200
|
|
1230
|
+
*/
|
|
1231
|
+
200: {
|
|
1232
|
+
/**
|
|
1233
|
+
* Error code from upstream
|
|
1234
|
+
*/
|
|
1235
|
+
code?: unknown;
|
|
1236
|
+
/**
|
|
1237
|
+
* Generic response data, specific schema depends on the endpoint
|
|
1238
|
+
*/
|
|
1239
|
+
data?: Array<{
|
|
1240
|
+
/**
|
|
1241
|
+
* Unique identifier of the host device
|
|
1242
|
+
*/
|
|
1243
|
+
id?: string;
|
|
1244
|
+
/**
|
|
1245
|
+
* Hardware identifier of the device
|
|
1246
|
+
*/
|
|
1247
|
+
hardwareId?: string;
|
|
1248
|
+
/**
|
|
1249
|
+
* Type of the device (console, network-server)
|
|
1250
|
+
*/
|
|
1251
|
+
type?: string;
|
|
1252
|
+
/**
|
|
1253
|
+
* Current IP address of the device
|
|
1254
|
+
*/
|
|
1255
|
+
ipAddress?: string;
|
|
1256
|
+
/**
|
|
1257
|
+
* Indicates if the current user is the owner of this device
|
|
1258
|
+
*/
|
|
1259
|
+
owner?: boolean;
|
|
1260
|
+
/**
|
|
1261
|
+
* Indicates if the device is blocked from cloud access
|
|
1262
|
+
*/
|
|
1263
|
+
isBlocked?: boolean;
|
|
1264
|
+
/**
|
|
1265
|
+
* Time in RFC3339 format when the device was registered to the cloud
|
|
1266
|
+
*/
|
|
1267
|
+
registrationTime?: string;
|
|
1268
|
+
/**
|
|
1269
|
+
* Time in RFC3339 format when the connection state last changed
|
|
1270
|
+
*/
|
|
1271
|
+
lastConnectionStateChange?: string;
|
|
1272
|
+
/**
|
|
1273
|
+
* Time in RFC3339 format of the latest device backup
|
|
1274
|
+
*/
|
|
1275
|
+
latestBackupTime?: string;
|
|
1276
|
+
/**
|
|
1277
|
+
* User-specific data associated with the device including permissions and role information
|
|
1278
|
+
*/
|
|
1279
|
+
userData?: unknown;
|
|
1280
|
+
/**
|
|
1281
|
+
* Device's reported state information
|
|
1282
|
+
*/
|
|
1283
|
+
reportedState?: unknown;
|
|
1284
|
+
}>;
|
|
1285
|
+
/**
|
|
1286
|
+
* HTTP status code
|
|
1287
|
+
*/
|
|
1288
|
+
httpStatusCode?: number;
|
|
1289
|
+
/**
|
|
1290
|
+
* Request trace identifier
|
|
1291
|
+
*/
|
|
1292
|
+
traceId?: string;
|
|
1293
|
+
/**
|
|
1294
|
+
* Pagination token for fetching the next set of results
|
|
1295
|
+
*/
|
|
1296
|
+
nextToken?: string;
|
|
1297
|
+
};
|
|
1298
|
+
};
|
|
1299
|
+
export type ListHostsResponse = ListHostsResponses[keyof ListHostsResponses];
|
|
1300
|
+
export type GetHostByIdData = {
|
|
1301
|
+
body?: never;
|
|
1302
|
+
path: {
|
|
1303
|
+
/**
|
|
1304
|
+
* Unique identifier of the host
|
|
1305
|
+
*/
|
|
1306
|
+
id: string;
|
|
1307
|
+
};
|
|
1308
|
+
query?: never;
|
|
1309
|
+
url: '/v1/hosts/{id}';
|
|
1310
|
+
};
|
|
1311
|
+
export type GetHostByIdErrors = {
|
|
1312
|
+
/**
|
|
1313
|
+
* 401
|
|
1314
|
+
*/
|
|
1315
|
+
401: {
|
|
1316
|
+
/**
|
|
1317
|
+
* Error code from upstream
|
|
1318
|
+
*/
|
|
1319
|
+
code?: unknown;
|
|
1320
|
+
/**
|
|
1321
|
+
* HTTP status code
|
|
1322
|
+
*/
|
|
1323
|
+
httpStatusCode?: number;
|
|
1324
|
+
/**
|
|
1325
|
+
* Error message
|
|
1326
|
+
*/
|
|
1327
|
+
message?: string;
|
|
1328
|
+
/**
|
|
1329
|
+
* Request trace identifier
|
|
1330
|
+
*/
|
|
1331
|
+
traceId?: string;
|
|
1332
|
+
};
|
|
1333
|
+
/**
|
|
1334
|
+
* 404
|
|
1335
|
+
*/
|
|
1336
|
+
404: {
|
|
1337
|
+
/**
|
|
1338
|
+
* Error code from upstream
|
|
1339
|
+
*/
|
|
1340
|
+
code?: unknown;
|
|
1341
|
+
/**
|
|
1342
|
+
* HTTP status code
|
|
1343
|
+
*/
|
|
1344
|
+
httpStatusCode?: number;
|
|
1345
|
+
/**
|
|
1346
|
+
* Error message
|
|
1347
|
+
*/
|
|
1348
|
+
message?: string;
|
|
1349
|
+
/**
|
|
1350
|
+
* Request trace identifier
|
|
1351
|
+
*/
|
|
1352
|
+
traceId?: string;
|
|
1353
|
+
};
|
|
1354
|
+
/**
|
|
1355
|
+
* 429
|
|
1356
|
+
*/
|
|
1357
|
+
429: {
|
|
1358
|
+
/**
|
|
1359
|
+
* Error code from upstream
|
|
1360
|
+
*/
|
|
1361
|
+
code?: unknown;
|
|
1362
|
+
/**
|
|
1363
|
+
* HTTP status code
|
|
1364
|
+
*/
|
|
1365
|
+
httpStatusCode?: number;
|
|
1366
|
+
/**
|
|
1367
|
+
* Error message
|
|
1368
|
+
*/
|
|
1369
|
+
message?: string;
|
|
1370
|
+
/**
|
|
1371
|
+
* Request trace identifier
|
|
1372
|
+
*/
|
|
1373
|
+
traceId?: string;
|
|
1374
|
+
};
|
|
1375
|
+
/**
|
|
1376
|
+
* 500
|
|
1377
|
+
*/
|
|
1378
|
+
500: {
|
|
1379
|
+
/**
|
|
1380
|
+
* Error code from upstream
|
|
1381
|
+
*/
|
|
1382
|
+
code?: unknown;
|
|
1383
|
+
/**
|
|
1384
|
+
* HTTP status code
|
|
1385
|
+
*/
|
|
1386
|
+
httpStatusCode?: number;
|
|
1387
|
+
/**
|
|
1388
|
+
* Error message
|
|
1389
|
+
*/
|
|
1390
|
+
message?: string;
|
|
1391
|
+
/**
|
|
1392
|
+
* Request trace identifier
|
|
1393
|
+
*/
|
|
1394
|
+
traceId?: string;
|
|
1395
|
+
};
|
|
1396
|
+
/**
|
|
1397
|
+
* 502
|
|
1398
|
+
*/
|
|
1399
|
+
502: {
|
|
1400
|
+
/**
|
|
1401
|
+
* Error code from upstream
|
|
1402
|
+
*/
|
|
1403
|
+
code?: unknown;
|
|
1404
|
+
/**
|
|
1405
|
+
* HTTP status code
|
|
1406
|
+
*/
|
|
1407
|
+
httpStatusCode?: number;
|
|
1408
|
+
/**
|
|
1409
|
+
* Error message
|
|
1410
|
+
*/
|
|
1411
|
+
message?: string;
|
|
1412
|
+
/**
|
|
1413
|
+
* Request trace identifier
|
|
1414
|
+
*/
|
|
1415
|
+
traceId?: string;
|
|
1416
|
+
};
|
|
1417
|
+
};
|
|
1418
|
+
export type GetHostByIdError = GetHostByIdErrors[keyof GetHostByIdErrors];
|
|
1419
|
+
export type GetHostByIdResponses = {
|
|
1420
|
+
/**
|
|
1421
|
+
* 200
|
|
1422
|
+
*/
|
|
1423
|
+
200: {
|
|
1424
|
+
/**
|
|
1425
|
+
* Generic response data, specific schema depends on the endpoint
|
|
1426
|
+
*/
|
|
1427
|
+
data?: {
|
|
1428
|
+
/**
|
|
1429
|
+
* Unique identifier of the host device
|
|
1430
|
+
*/
|
|
1431
|
+
id?: string;
|
|
1432
|
+
/**
|
|
1433
|
+
* Hardware identifier of the device
|
|
1434
|
+
*/
|
|
1435
|
+
hardwareId?: string;
|
|
1436
|
+
/**
|
|
1437
|
+
* Type of the device (console, network-server)
|
|
1438
|
+
*/
|
|
1439
|
+
type?: string;
|
|
1440
|
+
/**
|
|
1441
|
+
* Current IP address of the device
|
|
1442
|
+
*/
|
|
1443
|
+
ipAddress?: string;
|
|
1444
|
+
/**
|
|
1445
|
+
* Indicates if the current user is the owner of this device
|
|
1446
|
+
*/
|
|
1447
|
+
owner?: boolean;
|
|
1448
|
+
/**
|
|
1449
|
+
* Indicates if the device is blocked from cloud access
|
|
1450
|
+
*/
|
|
1451
|
+
isBlocked?: boolean;
|
|
1452
|
+
/**
|
|
1453
|
+
* Time in RFC3339 format when the device was registered to the cloud
|
|
1454
|
+
*/
|
|
1455
|
+
registrationTime?: string;
|
|
1456
|
+
/**
|
|
1457
|
+
* Time in RFC3339 format when the connection state last changed
|
|
1458
|
+
*/
|
|
1459
|
+
lastConnectionStateChange?: string;
|
|
1460
|
+
/**
|
|
1461
|
+
* Time in RFC3339 format of the latest device backup
|
|
1462
|
+
*/
|
|
1463
|
+
latestBackupTime?: string;
|
|
1464
|
+
/**
|
|
1465
|
+
* User-specific data associated with the device including permissions and role information
|
|
1466
|
+
*/
|
|
1467
|
+
userData?: unknown;
|
|
1468
|
+
/**
|
|
1469
|
+
* Device's reported state information
|
|
1470
|
+
*/
|
|
1471
|
+
reportedState?: unknown;
|
|
1472
|
+
};
|
|
1473
|
+
/**
|
|
1474
|
+
* HTTP status code
|
|
1475
|
+
*/
|
|
1476
|
+
httpStatusCode?: number;
|
|
1477
|
+
/**
|
|
1478
|
+
* Request trace identifier
|
|
1479
|
+
*/
|
|
1480
|
+
traceId?: string;
|
|
1481
|
+
};
|
|
1482
|
+
};
|
|
1483
|
+
export type GetHostByIdResponse = GetHostByIdResponses[keyof GetHostByIdResponses];
|
|
1484
|
+
export type GetIspMetricsData = {
|
|
1485
|
+
body?: never;
|
|
1486
|
+
path: {
|
|
1487
|
+
/**
|
|
1488
|
+
* Specifies whether metrics are returned using `5m` or `1h` intervals
|
|
1489
|
+
*/
|
|
1490
|
+
type: string;
|
|
1491
|
+
};
|
|
1492
|
+
query?: {
|
|
1493
|
+
/**
|
|
1494
|
+
* The earliest timestamp to retrieve data from (RFC3339 format)
|
|
1495
|
+
*/
|
|
1496
|
+
beginTimestamp?: string;
|
|
1497
|
+
/**
|
|
1498
|
+
* The latest timestamp to retrieve data up to (RFC3339 format)
|
|
1499
|
+
*/
|
|
1500
|
+
endTimestamp?: string;
|
|
1501
|
+
/**
|
|
1502
|
+
* Specifies the time range of metrics to retrieve, starting from when the request is made. Supports `24h` for 5-minute metrics, and `7d` or `30d` for 1-hour metrics. This parameter **cannot** be used with `beginTimestamp` or `endTimestamp`.
|
|
1503
|
+
*/
|
|
1504
|
+
duration?: string;
|
|
1505
|
+
};
|
|
1506
|
+
url: '/v1/isp-metrics/{type}';
|
|
1507
|
+
};
|
|
1508
|
+
export type GetIspMetricsErrors = {
|
|
1509
|
+
/**
|
|
1510
|
+
* 400
|
|
1511
|
+
*/
|
|
1512
|
+
400: {
|
|
1513
|
+
/**
|
|
1514
|
+
* Error code from upstream
|
|
1515
|
+
*/
|
|
1516
|
+
code?: unknown;
|
|
1517
|
+
/**
|
|
1518
|
+
* HTTP status code
|
|
1519
|
+
*/
|
|
1520
|
+
httpStatusCode?: number;
|
|
1521
|
+
/**
|
|
1522
|
+
* Error message
|
|
1523
|
+
*/
|
|
1524
|
+
message?: string;
|
|
1525
|
+
/**
|
|
1526
|
+
* Request trace identifier
|
|
1527
|
+
*/
|
|
1528
|
+
traceId?: string;
|
|
1529
|
+
};
|
|
1530
|
+
/**
|
|
1531
|
+
* 401
|
|
1532
|
+
*/
|
|
1533
|
+
401: {
|
|
1534
|
+
/**
|
|
1535
|
+
* Error code from upstream
|
|
1536
|
+
*/
|
|
1537
|
+
code?: unknown;
|
|
1538
|
+
/**
|
|
1539
|
+
* HTTP status code
|
|
1540
|
+
*/
|
|
1541
|
+
httpStatusCode?: number;
|
|
1542
|
+
/**
|
|
1543
|
+
* Error message
|
|
1544
|
+
*/
|
|
1545
|
+
message?: string;
|
|
1546
|
+
/**
|
|
1547
|
+
* Request trace identifier
|
|
1548
|
+
*/
|
|
1549
|
+
traceId?: string;
|
|
1550
|
+
};
|
|
1551
|
+
/**
|
|
1552
|
+
* 429
|
|
1553
|
+
*/
|
|
1554
|
+
429: {
|
|
1555
|
+
/**
|
|
1556
|
+
* Error code from upstream
|
|
1557
|
+
*/
|
|
1558
|
+
code?: unknown;
|
|
1559
|
+
/**
|
|
1560
|
+
* HTTP status code
|
|
1561
|
+
*/
|
|
1562
|
+
httpStatusCode?: number;
|
|
1563
|
+
/**
|
|
1564
|
+
* Error message
|
|
1565
|
+
*/
|
|
1566
|
+
message?: string;
|
|
1567
|
+
/**
|
|
1568
|
+
* Request trace identifier
|
|
1569
|
+
*/
|
|
1570
|
+
traceId?: string;
|
|
1571
|
+
};
|
|
1572
|
+
/**
|
|
1573
|
+
* 500
|
|
1574
|
+
*/
|
|
1575
|
+
500: {
|
|
1576
|
+
/**
|
|
1577
|
+
* Error code from upstream
|
|
1578
|
+
*/
|
|
1579
|
+
code?: unknown;
|
|
1580
|
+
/**
|
|
1581
|
+
* HTTP status code
|
|
1582
|
+
*/
|
|
1583
|
+
httpStatusCode?: number;
|
|
1584
|
+
/**
|
|
1585
|
+
* Error message
|
|
1586
|
+
*/
|
|
1587
|
+
message?: string;
|
|
1588
|
+
/**
|
|
1589
|
+
* Request trace identifier
|
|
1590
|
+
*/
|
|
1591
|
+
traceId?: string;
|
|
1592
|
+
};
|
|
1593
|
+
/**
|
|
1594
|
+
* 502
|
|
1595
|
+
*/
|
|
1596
|
+
502: {
|
|
1597
|
+
/**
|
|
1598
|
+
* Error code from upstream
|
|
1599
|
+
*/
|
|
1600
|
+
code?: unknown;
|
|
1601
|
+
/**
|
|
1602
|
+
* HTTP status code
|
|
1603
|
+
*/
|
|
1604
|
+
httpStatusCode?: number;
|
|
1605
|
+
/**
|
|
1606
|
+
* Error message
|
|
1607
|
+
*/
|
|
1608
|
+
message?: string;
|
|
1609
|
+
/**
|
|
1610
|
+
* Request trace identifier
|
|
1611
|
+
*/
|
|
1612
|
+
traceId?: string;
|
|
1613
|
+
};
|
|
1614
|
+
};
|
|
1615
|
+
export type GetIspMetricsError = GetIspMetricsErrors[keyof GetIspMetricsErrors];
|
|
1616
|
+
export type GetIspMetricsResponses = {
|
|
1617
|
+
/**
|
|
1618
|
+
* 200
|
|
1619
|
+
*/
|
|
1620
|
+
200: {
|
|
1621
|
+
/**
|
|
1622
|
+
* Generic response data, specific schema depends on the endpoint
|
|
1623
|
+
*/
|
|
1624
|
+
data?: Array<{
|
|
1625
|
+
metricType?: string;
|
|
1626
|
+
periods?: Array<{
|
|
1627
|
+
data?: {
|
|
1628
|
+
wan?: {
|
|
1629
|
+
avgLatency?: number;
|
|
1630
|
+
download_kbps?: number;
|
|
1631
|
+
downtime?: number;
|
|
1632
|
+
ispAsn?: string;
|
|
1633
|
+
ispName?: string;
|
|
1634
|
+
maxLatency?: number;
|
|
1635
|
+
packetLoss?: number;
|
|
1636
|
+
upload_kbps?: number;
|
|
1637
|
+
uptime?: number;
|
|
1638
|
+
};
|
|
1639
|
+
};
|
|
1640
|
+
metricTime?: string;
|
|
1641
|
+
version?: string;
|
|
1642
|
+
} | null>;
|
|
1643
|
+
hostId?: string;
|
|
1644
|
+
siteId?: string;
|
|
1645
|
+
} | null>;
|
|
1646
|
+
/**
|
|
1647
|
+
* HTTP status code
|
|
1648
|
+
*/
|
|
1649
|
+
httpStatusCode?: number;
|
|
1650
|
+
/**
|
|
1651
|
+
* Request trace identifier
|
|
1652
|
+
*/
|
|
1653
|
+
traceId?: string;
|
|
1654
|
+
};
|
|
1655
|
+
};
|
|
1656
|
+
export type GetIspMetricsResponse = GetIspMetricsResponses[keyof GetIspMetricsResponses];
|
|
1657
|
+
export type QueryIspMetricsData = {
|
|
1658
|
+
body?: {
|
|
1659
|
+
sites?: Array<{
|
|
1660
|
+
beginTimestamp?: string;
|
|
1661
|
+
hostId: string;
|
|
1662
|
+
endTimestamp?: string;
|
|
1663
|
+
siteId: string;
|
|
1664
|
+
} | null>;
|
|
1665
|
+
};
|
|
1666
|
+
path: {
|
|
1667
|
+
/**
|
|
1668
|
+
* Specifies whether metrics are returned using `5m` or `1h` intervals
|
|
1669
|
+
*/
|
|
1670
|
+
type: string;
|
|
1671
|
+
};
|
|
1672
|
+
query?: never;
|
|
1673
|
+
url: '/v1/isp-metrics/{type}/query';
|
|
1674
|
+
};
|
|
1675
|
+
export type QueryIspMetricsErrors = {
|
|
1676
|
+
/**
|
|
1677
|
+
* 400
|
|
1678
|
+
*/
|
|
1679
|
+
400: {
|
|
1680
|
+
/**
|
|
1681
|
+
* Error code from upstream
|
|
1682
|
+
*/
|
|
1683
|
+
code?: unknown;
|
|
1684
|
+
/**
|
|
1685
|
+
* HTTP status code
|
|
1686
|
+
*/
|
|
1687
|
+
httpStatusCode?: number;
|
|
1688
|
+
/**
|
|
1689
|
+
* Error message
|
|
1690
|
+
*/
|
|
1691
|
+
message?: string;
|
|
1692
|
+
/**
|
|
1693
|
+
* Request trace identifier
|
|
1694
|
+
*/
|
|
1695
|
+
traceId?: string;
|
|
1696
|
+
};
|
|
1697
|
+
/**
|
|
1698
|
+
* 401
|
|
1699
|
+
*/
|
|
1700
|
+
401: {
|
|
1701
|
+
/**
|
|
1702
|
+
* Error code from upstream
|
|
1703
|
+
*/
|
|
1704
|
+
code?: unknown;
|
|
1705
|
+
/**
|
|
1706
|
+
* HTTP status code
|
|
1707
|
+
*/
|
|
1708
|
+
httpStatusCode?: number;
|
|
1709
|
+
/**
|
|
1710
|
+
* Error message
|
|
1711
|
+
*/
|
|
1712
|
+
message?: string;
|
|
1713
|
+
/**
|
|
1714
|
+
* Request trace identifier
|
|
1715
|
+
*/
|
|
1716
|
+
traceId?: string;
|
|
1717
|
+
};
|
|
1718
|
+
/**
|
|
1719
|
+
* 429
|
|
1720
|
+
*/
|
|
1721
|
+
429: {
|
|
1722
|
+
/**
|
|
1723
|
+
* Error code from upstream
|
|
1724
|
+
*/
|
|
1725
|
+
code?: unknown;
|
|
1726
|
+
/**
|
|
1727
|
+
* HTTP status code
|
|
1728
|
+
*/
|
|
1729
|
+
httpStatusCode?: number;
|
|
1730
|
+
/**
|
|
1731
|
+
* Error message
|
|
1732
|
+
*/
|
|
1733
|
+
message?: string;
|
|
1734
|
+
/**
|
|
1735
|
+
* Request trace identifier
|
|
1736
|
+
*/
|
|
1737
|
+
traceId?: string;
|
|
1738
|
+
};
|
|
1739
|
+
/**
|
|
1740
|
+
* 500
|
|
1741
|
+
*/
|
|
1742
|
+
500: {
|
|
1743
|
+
/**
|
|
1744
|
+
* Error code from upstream
|
|
1745
|
+
*/
|
|
1746
|
+
code?: unknown;
|
|
1747
|
+
/**
|
|
1748
|
+
* HTTP status code
|
|
1749
|
+
*/
|
|
1750
|
+
httpStatusCode?: number;
|
|
1751
|
+
/**
|
|
1752
|
+
* Error message
|
|
1753
|
+
*/
|
|
1754
|
+
message?: string;
|
|
1755
|
+
/**
|
|
1756
|
+
* Request trace identifier
|
|
1757
|
+
*/
|
|
1758
|
+
traceId?: string;
|
|
1759
|
+
};
|
|
1760
|
+
/**
|
|
1761
|
+
* 502
|
|
1762
|
+
*/
|
|
1763
|
+
502: {
|
|
1764
|
+
/**
|
|
1765
|
+
* Error code from upstream
|
|
1766
|
+
*/
|
|
1767
|
+
code?: unknown;
|
|
1768
|
+
/**
|
|
1769
|
+
* HTTP status code
|
|
1770
|
+
*/
|
|
1771
|
+
httpStatusCode?: number;
|
|
1772
|
+
/**
|
|
1773
|
+
* Error message
|
|
1774
|
+
*/
|
|
1775
|
+
message?: string;
|
|
1776
|
+
/**
|
|
1777
|
+
* Request trace identifier
|
|
1778
|
+
*/
|
|
1779
|
+
traceId?: string;
|
|
1780
|
+
};
|
|
1781
|
+
};
|
|
1782
|
+
export type QueryIspMetricsError = QueryIspMetricsErrors[keyof QueryIspMetricsErrors];
|
|
1783
|
+
export type QueryIspMetricsResponses = {
|
|
1784
|
+
/**
|
|
1785
|
+
* 200
|
|
1786
|
+
*/
|
|
1787
|
+
200: {
|
|
1788
|
+
/**
|
|
1789
|
+
* Generic response data, specific schema depends on the endpoint
|
|
1790
|
+
*/
|
|
1791
|
+
data?: {
|
|
1792
|
+
metrics?: Array<{
|
|
1793
|
+
metricType?: string;
|
|
1794
|
+
periods?: Array<{
|
|
1795
|
+
data?: {
|
|
1796
|
+
wan?: {
|
|
1797
|
+
avgLatency?: number;
|
|
1798
|
+
download_kbps?: number;
|
|
1799
|
+
downtime?: number;
|
|
1800
|
+
ispAsn?: string;
|
|
1801
|
+
ispName?: string;
|
|
1802
|
+
maxLatency?: number;
|
|
1803
|
+
packetLoss?: number;
|
|
1804
|
+
upload_kbps?: number;
|
|
1805
|
+
uptime?: number;
|
|
1806
|
+
};
|
|
1807
|
+
};
|
|
1808
|
+
metricTime?: string;
|
|
1809
|
+
version?: string;
|
|
1810
|
+
} | null>;
|
|
1811
|
+
hostId?: string;
|
|
1812
|
+
siteId?: string;
|
|
1813
|
+
} | null>;
|
|
1814
|
+
message?: string | null;
|
|
1815
|
+
status?: string | null;
|
|
1816
|
+
} | null;
|
|
1817
|
+
/**
|
|
1818
|
+
* HTTP status code
|
|
1819
|
+
*/
|
|
1820
|
+
httpStatusCode?: number;
|
|
1821
|
+
/**
|
|
1822
|
+
* Request trace identifier
|
|
1823
|
+
*/
|
|
1824
|
+
traceId?: string;
|
|
1825
|
+
};
|
|
1826
|
+
};
|
|
1827
|
+
export type QueryIspMetricsResponse = QueryIspMetricsResponses[keyof QueryIspMetricsResponses];
|
|
1828
|
+
export type ListSdWanConfigsData = {
|
|
1829
|
+
body?: never;
|
|
1830
|
+
path?: never;
|
|
1831
|
+
query?: never;
|
|
1832
|
+
url: '/v1/sd-wan-configs';
|
|
1833
|
+
};
|
|
1834
|
+
export type ListSdWanConfigsErrors = {
|
|
1835
|
+
/**
|
|
1836
|
+
* 401
|
|
1837
|
+
*/
|
|
1838
|
+
401: {
|
|
1839
|
+
/**
|
|
1840
|
+
* Error code from upstream
|
|
1841
|
+
*/
|
|
1842
|
+
code?: unknown;
|
|
1843
|
+
/**
|
|
1844
|
+
* HTTP status code
|
|
1845
|
+
*/
|
|
1846
|
+
httpStatusCode?: number;
|
|
1847
|
+
/**
|
|
1848
|
+
* Error message
|
|
1849
|
+
*/
|
|
1850
|
+
message?: string;
|
|
1851
|
+
/**
|
|
1852
|
+
* Request trace identifier
|
|
1853
|
+
*/
|
|
1854
|
+
traceId?: string;
|
|
1855
|
+
};
|
|
1856
|
+
/**
|
|
1857
|
+
* 429
|
|
1858
|
+
*/
|
|
1859
|
+
429: {
|
|
1860
|
+
/**
|
|
1861
|
+
* Error code from upstream
|
|
1862
|
+
*/
|
|
1863
|
+
code?: unknown;
|
|
1864
|
+
/**
|
|
1865
|
+
* HTTP status code
|
|
1866
|
+
*/
|
|
1867
|
+
httpStatusCode?: number;
|
|
1868
|
+
/**
|
|
1869
|
+
* Error message
|
|
1870
|
+
*/
|
|
1871
|
+
message?: string;
|
|
1872
|
+
/**
|
|
1873
|
+
* Request trace identifier
|
|
1874
|
+
*/
|
|
1875
|
+
traceId?: string;
|
|
1876
|
+
};
|
|
1877
|
+
/**
|
|
1878
|
+
* 500
|
|
1879
|
+
*/
|
|
1880
|
+
500: {
|
|
1881
|
+
/**
|
|
1882
|
+
* Error code from upstream
|
|
1883
|
+
*/
|
|
1884
|
+
code?: unknown;
|
|
1885
|
+
/**
|
|
1886
|
+
* HTTP status code
|
|
1887
|
+
*/
|
|
1888
|
+
httpStatusCode?: number;
|
|
1889
|
+
/**
|
|
1890
|
+
* Error message
|
|
1891
|
+
*/
|
|
1892
|
+
message?: string;
|
|
1893
|
+
/**
|
|
1894
|
+
* Request trace identifier
|
|
1895
|
+
*/
|
|
1896
|
+
traceId?: string;
|
|
1897
|
+
};
|
|
1898
|
+
/**
|
|
1899
|
+
* 502
|
|
1900
|
+
*/
|
|
1901
|
+
502: {
|
|
1902
|
+
/**
|
|
1903
|
+
* Error code from upstream
|
|
1904
|
+
*/
|
|
1905
|
+
code?: unknown;
|
|
1906
|
+
/**
|
|
1907
|
+
* HTTP status code
|
|
1908
|
+
*/
|
|
1909
|
+
httpStatusCode?: number;
|
|
1910
|
+
/**
|
|
1911
|
+
* Error message
|
|
1912
|
+
*/
|
|
1913
|
+
message?: string;
|
|
1914
|
+
/**
|
|
1915
|
+
* Request trace identifier
|
|
1916
|
+
*/
|
|
1917
|
+
traceId?: string;
|
|
1918
|
+
};
|
|
1919
|
+
};
|
|
1920
|
+
export type ListSdWanConfigsError = ListSdWanConfigsErrors[keyof ListSdWanConfigsErrors];
|
|
1921
|
+
export type ListSdWanConfigsResponses = {
|
|
1922
|
+
/**
|
|
1923
|
+
* 200
|
|
1924
|
+
*/
|
|
1925
|
+
200: {
|
|
1926
|
+
/**
|
|
1927
|
+
* Generic response data, specific schema depends on the endpoint
|
|
1928
|
+
*/
|
|
1929
|
+
data?: Array<{
|
|
1930
|
+
/**
|
|
1931
|
+
* Unique identifier of the SD-WAN config
|
|
1932
|
+
*/
|
|
1933
|
+
id?: string;
|
|
1934
|
+
/**
|
|
1935
|
+
* Name of the SD-WAN config
|
|
1936
|
+
*/
|
|
1937
|
+
name?: string;
|
|
1938
|
+
/**
|
|
1939
|
+
* Type of SD-WAN config - Currently only supports sdwan-hbsp
|
|
1940
|
+
*/
|
|
1941
|
+
type?: [
|
|
1942
|
+
'sdwan-hbsp'
|
|
1943
|
+
];
|
|
1944
|
+
}>;
|
|
1945
|
+
/**
|
|
1946
|
+
* HTTP status code
|
|
1947
|
+
*/
|
|
1948
|
+
httpStatusCode?: number;
|
|
1949
|
+
/**
|
|
1950
|
+
* Request trace identifier
|
|
1951
|
+
*/
|
|
1952
|
+
traceId?: string;
|
|
1953
|
+
};
|
|
1954
|
+
};
|
|
1955
|
+
export type ListSdWanConfigsResponse = ListSdWanConfigsResponses[keyof ListSdWanConfigsResponses];
|
|
1956
|
+
export type GetSdWanConfigByIdData = {
|
|
1957
|
+
body?: never;
|
|
1958
|
+
path: {
|
|
1959
|
+
/**
|
|
1960
|
+
* Unique identifier of the SD-WAN configuration
|
|
1961
|
+
*/
|
|
1962
|
+
id: string;
|
|
1963
|
+
};
|
|
1964
|
+
query?: never;
|
|
1965
|
+
url: '/v1/sd-wan-configs/{id}';
|
|
1966
|
+
};
|
|
1967
|
+
export type GetSdWanConfigByIdErrors = {
|
|
1968
|
+
/**
|
|
1969
|
+
* 401
|
|
1970
|
+
*/
|
|
1971
|
+
401: {
|
|
1972
|
+
/**
|
|
1973
|
+
* Error code from upstream
|
|
1974
|
+
*/
|
|
1975
|
+
code?: unknown;
|
|
1976
|
+
/**
|
|
1977
|
+
* HTTP status code
|
|
1978
|
+
*/
|
|
1979
|
+
httpStatusCode?: number;
|
|
1980
|
+
/**
|
|
1981
|
+
* Error message
|
|
1982
|
+
*/
|
|
1983
|
+
message?: string;
|
|
1984
|
+
/**
|
|
1985
|
+
* Request trace identifier
|
|
1986
|
+
*/
|
|
1987
|
+
traceId?: string;
|
|
1988
|
+
};
|
|
1989
|
+
/**
|
|
1990
|
+
* 404
|
|
1991
|
+
*/
|
|
1992
|
+
404: {
|
|
1993
|
+
/**
|
|
1994
|
+
* Error code from upstream
|
|
1995
|
+
*/
|
|
1996
|
+
code?: unknown;
|
|
1997
|
+
/**
|
|
1998
|
+
* HTTP status code
|
|
1999
|
+
*/
|
|
2000
|
+
httpStatusCode?: number;
|
|
2001
|
+
/**
|
|
2002
|
+
* Error message
|
|
2003
|
+
*/
|
|
2004
|
+
message?: string;
|
|
2005
|
+
/**
|
|
2006
|
+
* Request trace identifier
|
|
2007
|
+
*/
|
|
2008
|
+
traceId?: string;
|
|
2009
|
+
};
|
|
2010
|
+
/**
|
|
2011
|
+
* 429
|
|
2012
|
+
*/
|
|
2013
|
+
429: {
|
|
2014
|
+
/**
|
|
2015
|
+
* Error code from upstream
|
|
2016
|
+
*/
|
|
2017
|
+
code?: unknown;
|
|
2018
|
+
/**
|
|
2019
|
+
* HTTP status code
|
|
2020
|
+
*/
|
|
2021
|
+
httpStatusCode?: number;
|
|
2022
|
+
/**
|
|
2023
|
+
* Error message
|
|
2024
|
+
*/
|
|
2025
|
+
message?: string;
|
|
2026
|
+
/**
|
|
2027
|
+
* Request trace identifier
|
|
2028
|
+
*/
|
|
2029
|
+
traceId?: string;
|
|
2030
|
+
};
|
|
2031
|
+
/**
|
|
2032
|
+
* 500
|
|
2033
|
+
*/
|
|
2034
|
+
500: {
|
|
2035
|
+
/**
|
|
2036
|
+
* Error code from upstream
|
|
2037
|
+
*/
|
|
2038
|
+
code?: unknown;
|
|
2039
|
+
/**
|
|
2040
|
+
* HTTP status code
|
|
2041
|
+
*/
|
|
2042
|
+
httpStatusCode?: number;
|
|
2043
|
+
/**
|
|
2044
|
+
* Error message
|
|
2045
|
+
*/
|
|
2046
|
+
message?: string;
|
|
2047
|
+
/**
|
|
2048
|
+
* Request trace identifier
|
|
2049
|
+
*/
|
|
2050
|
+
traceId?: string;
|
|
2051
|
+
};
|
|
2052
|
+
/**
|
|
2053
|
+
* 502
|
|
2054
|
+
*/
|
|
2055
|
+
502: {
|
|
2056
|
+
/**
|
|
2057
|
+
* Error code from upstream
|
|
2058
|
+
*/
|
|
2059
|
+
code?: unknown;
|
|
2060
|
+
/**
|
|
2061
|
+
* HTTP status code
|
|
2062
|
+
*/
|
|
2063
|
+
httpStatusCode?: number;
|
|
2064
|
+
/**
|
|
2065
|
+
* Error message
|
|
2066
|
+
*/
|
|
2067
|
+
message?: string;
|
|
2068
|
+
/**
|
|
2069
|
+
* Request trace identifier
|
|
2070
|
+
*/
|
|
2071
|
+
traceId?: string;
|
|
2072
|
+
};
|
|
2073
|
+
};
|
|
2074
|
+
export type GetSdWanConfigByIdError = GetSdWanConfigByIdErrors[keyof GetSdWanConfigByIdErrors];
|
|
2075
|
+
export type GetSdWanConfigByIdResponses = {
|
|
2076
|
+
/**
|
|
2077
|
+
* 200
|
|
2078
|
+
*/
|
|
2079
|
+
200: {
|
|
2080
|
+
/**
|
|
2081
|
+
* Generic response data, specific schema depends on the endpoint
|
|
2082
|
+
*/
|
|
2083
|
+
data?: {
|
|
2084
|
+
/**
|
|
2085
|
+
* Unique identifier of the SD-WAN config
|
|
2086
|
+
*/
|
|
2087
|
+
id?: string;
|
|
2088
|
+
/**
|
|
2089
|
+
* Name of the SD-WAN config
|
|
2090
|
+
*/
|
|
2091
|
+
name?: string;
|
|
2092
|
+
/**
|
|
2093
|
+
* Type of SD-WAN config - Currently only supports sdwan-hbsp
|
|
2094
|
+
*/
|
|
2095
|
+
type?: [
|
|
2096
|
+
'sdwan-hbsp'
|
|
2097
|
+
];
|
|
2098
|
+
/**
|
|
2099
|
+
* Variant of SD-WAN configuration
|
|
2100
|
+
*/
|
|
2101
|
+
variant?: [
|
|
2102
|
+
'distributed',
|
|
2103
|
+
'failover',
|
|
2104
|
+
'single'
|
|
2105
|
+
];
|
|
2106
|
+
/**
|
|
2107
|
+
* Advanced settings
|
|
2108
|
+
*/
|
|
2109
|
+
settings?: {
|
|
2110
|
+
hubsInterconnect?: boolean | null;
|
|
2111
|
+
spokeToHubTunnelsMode?: [
|
|
2112
|
+
'maxResiliency',
|
|
2113
|
+
'redundant',
|
|
2114
|
+
'scalable'
|
|
2115
|
+
];
|
|
2116
|
+
/**
|
|
2117
|
+
* Auto-assigns subnet and routes; otherwise, users enter them manually.
|
|
2118
|
+
*/
|
|
2119
|
+
spokesAutoScaleAndNatEnabled?: boolean;
|
|
2120
|
+
/**
|
|
2121
|
+
* Subnet in CIDR format, Example: 172.16.0.0/12
|
|
2122
|
+
*/
|
|
2123
|
+
spokesAutoScaleAndNatRange?: string | null;
|
|
2124
|
+
/**
|
|
2125
|
+
* Setting for NET: Spokes can reach hubs but not other spokes.
|
|
2126
|
+
*/
|
|
2127
|
+
spokesIsolate?: boolean;
|
|
2128
|
+
/**
|
|
2129
|
+
* Enable spoke standard settings
|
|
2130
|
+
*/
|
|
2131
|
+
spokeStandardSettingsEnabled?: boolean;
|
|
2132
|
+
/**
|
|
2133
|
+
* Spoke standard settings
|
|
2134
|
+
*/
|
|
2135
|
+
spokeStandardSettingsValues?: {
|
|
2136
|
+
/**
|
|
2137
|
+
* Example: 'WAN'
|
|
2138
|
+
*/
|
|
2139
|
+
primaryWan?: string | null;
|
|
2140
|
+
/**
|
|
2141
|
+
* Use fail over WAN.
|
|
2142
|
+
*/
|
|
2143
|
+
wanFailover?: boolean | null;
|
|
2144
|
+
} | null;
|
|
2145
|
+
spokeToHubRouting?: [
|
|
2146
|
+
'custom',
|
|
2147
|
+
'geo'
|
|
2148
|
+
];
|
|
2149
|
+
};
|
|
2150
|
+
hubs?: Array<{
|
|
2151
|
+
id?: string;
|
|
2152
|
+
hostId?: string;
|
|
2153
|
+
siteId?: string;
|
|
2154
|
+
/**
|
|
2155
|
+
* Ids of networks belonging to the hub
|
|
2156
|
+
*/
|
|
2157
|
+
networkIds?: Array<string>;
|
|
2158
|
+
/**
|
|
2159
|
+
* Subnets in CIDR format: 10.0.0.0/24
|
|
2160
|
+
*/
|
|
2161
|
+
routes?: Array<string>;
|
|
2162
|
+
/**
|
|
2163
|
+
* Example: 'WAN'
|
|
2164
|
+
*/
|
|
2165
|
+
primaryWan?: string;
|
|
2166
|
+
/**
|
|
2167
|
+
* Use fail over WAN.
|
|
2168
|
+
*/
|
|
2169
|
+
wanFailover?: boolean;
|
|
2170
|
+
}>;
|
|
2171
|
+
spokes?: Array<{
|
|
2172
|
+
id?: string;
|
|
2173
|
+
hostId?: string;
|
|
2174
|
+
siteId?: string;
|
|
2175
|
+
/**
|
|
2176
|
+
* Ids of networks belonging to the spoke
|
|
2177
|
+
*/
|
|
2178
|
+
networkIds?: Array<string>;
|
|
2179
|
+
/**
|
|
2180
|
+
* Subnets in CIDR format: 10.0.0.0/24
|
|
2181
|
+
*/
|
|
2182
|
+
routes?: Array<string>;
|
|
2183
|
+
/**
|
|
2184
|
+
* Example: 'WAN'
|
|
2185
|
+
*/
|
|
2186
|
+
primaryWan?: string;
|
|
2187
|
+
/**
|
|
2188
|
+
* Use fail over WAN.
|
|
2189
|
+
*/
|
|
2190
|
+
wanFailover?: boolean;
|
|
2191
|
+
/**
|
|
2192
|
+
* Non-null for distributed topology and spokeToHubRouting=custom
|
|
2193
|
+
*/
|
|
2194
|
+
hubsPriority?: Array<string>;
|
|
2195
|
+
}>;
|
|
2196
|
+
} | null;
|
|
2197
|
+
/**
|
|
2198
|
+
* HTTP status code
|
|
2199
|
+
*/
|
|
2200
|
+
httpStatusCode?: number;
|
|
2201
|
+
/**
|
|
2202
|
+
* Request trace identifier
|
|
2203
|
+
*/
|
|
2204
|
+
traceId?: string;
|
|
2205
|
+
};
|
|
2206
|
+
};
|
|
2207
|
+
export type GetSdWanConfigByIdResponse = GetSdWanConfigByIdResponses[keyof GetSdWanConfigByIdResponses];
|
|
2208
|
+
export type GetSdWanConfigStatusData = {
|
|
2209
|
+
body?: never;
|
|
2210
|
+
path: {
|
|
2211
|
+
/**
|
|
2212
|
+
* Unique identifier of the SD-WAN configuration
|
|
2213
|
+
*/
|
|
2214
|
+
id: string;
|
|
2215
|
+
};
|
|
2216
|
+
query?: never;
|
|
2217
|
+
url: '/v1/sd-wan-configs/{id}/status';
|
|
2218
|
+
};
|
|
2219
|
+
export type GetSdWanConfigStatusErrors = {
|
|
2220
|
+
/**
|
|
2221
|
+
* 401
|
|
2222
|
+
*/
|
|
2223
|
+
401: {
|
|
2224
|
+
/**
|
|
2225
|
+
* Error code from upstream
|
|
2226
|
+
*/
|
|
2227
|
+
code?: unknown;
|
|
2228
|
+
/**
|
|
2229
|
+
* HTTP status code
|
|
2230
|
+
*/
|
|
2231
|
+
httpStatusCode?: number;
|
|
2232
|
+
/**
|
|
2233
|
+
* Error message
|
|
2234
|
+
*/
|
|
2235
|
+
message?: string;
|
|
2236
|
+
/**
|
|
2237
|
+
* Request trace identifier
|
|
2238
|
+
*/
|
|
2239
|
+
traceId?: string;
|
|
2240
|
+
};
|
|
2241
|
+
/**
|
|
2242
|
+
* 404
|
|
2243
|
+
*/
|
|
2244
|
+
404: {
|
|
2245
|
+
/**
|
|
2246
|
+
* Error code from upstream
|
|
2247
|
+
*/
|
|
2248
|
+
code?: unknown;
|
|
2249
|
+
/**
|
|
2250
|
+
* HTTP status code
|
|
2251
|
+
*/
|
|
2252
|
+
httpStatusCode?: number;
|
|
2253
|
+
/**
|
|
2254
|
+
* Error message
|
|
2255
|
+
*/
|
|
2256
|
+
message?: string;
|
|
2257
|
+
/**
|
|
2258
|
+
* Request trace identifier
|
|
2259
|
+
*/
|
|
2260
|
+
traceId?: string;
|
|
2261
|
+
};
|
|
2262
|
+
/**
|
|
2263
|
+
* 429
|
|
2264
|
+
*/
|
|
2265
|
+
429: {
|
|
2266
|
+
/**
|
|
2267
|
+
* Error code from upstream
|
|
2268
|
+
*/
|
|
2269
|
+
code?: unknown;
|
|
2270
|
+
/**
|
|
2271
|
+
* HTTP status code
|
|
2272
|
+
*/
|
|
2273
|
+
httpStatusCode?: number;
|
|
2274
|
+
/**
|
|
2275
|
+
* Error message
|
|
2276
|
+
*/
|
|
2277
|
+
message?: string;
|
|
2278
|
+
/**
|
|
2279
|
+
* Request trace identifier
|
|
2280
|
+
*/
|
|
2281
|
+
traceId?: string;
|
|
2282
|
+
};
|
|
2283
|
+
/**
|
|
2284
|
+
* 500
|
|
2285
|
+
*/
|
|
2286
|
+
500: {
|
|
2287
|
+
/**
|
|
2288
|
+
* Error code from upstream
|
|
2289
|
+
*/
|
|
2290
|
+
code?: unknown;
|
|
2291
|
+
/**
|
|
2292
|
+
* HTTP status code
|
|
2293
|
+
*/
|
|
2294
|
+
httpStatusCode?: number;
|
|
2295
|
+
/**
|
|
2296
|
+
* Error message
|
|
2297
|
+
*/
|
|
2298
|
+
message?: string;
|
|
2299
|
+
/**
|
|
2300
|
+
* Request trace identifier
|
|
2301
|
+
*/
|
|
2302
|
+
traceId?: string;
|
|
2303
|
+
};
|
|
2304
|
+
/**
|
|
2305
|
+
* 502
|
|
2306
|
+
*/
|
|
2307
|
+
502: {
|
|
2308
|
+
/**
|
|
2309
|
+
* Error code from upstream
|
|
2310
|
+
*/
|
|
2311
|
+
code?: unknown;
|
|
2312
|
+
/**
|
|
2313
|
+
* HTTP status code
|
|
2314
|
+
*/
|
|
2315
|
+
httpStatusCode?: number;
|
|
2316
|
+
/**
|
|
2317
|
+
* Error message
|
|
2318
|
+
*/
|
|
2319
|
+
message?: string;
|
|
2320
|
+
/**
|
|
2321
|
+
* Request trace identifier
|
|
2322
|
+
*/
|
|
2323
|
+
traceId?: string;
|
|
2324
|
+
};
|
|
2325
|
+
};
|
|
2326
|
+
export type GetSdWanConfigStatusError = GetSdWanConfigStatusErrors[keyof GetSdWanConfigStatusErrors];
|
|
2327
|
+
export type GetSdWanConfigStatusResponses = {
|
|
2328
|
+
/**
|
|
2329
|
+
* 200
|
|
2330
|
+
*/
|
|
2331
|
+
200: {
|
|
2332
|
+
/**
|
|
2333
|
+
* Generic response data, specific schema depends on the endpoint
|
|
2334
|
+
*/
|
|
2335
|
+
data?: {
|
|
2336
|
+
/**
|
|
2337
|
+
* Unique identifier of the SD-WAN configuration
|
|
2338
|
+
*/
|
|
2339
|
+
id?: string;
|
|
2340
|
+
/**
|
|
2341
|
+
* A unique identifier representing the current state of the configuration.
|
|
2342
|
+
*/
|
|
2343
|
+
fingerprint?: string;
|
|
2344
|
+
/**
|
|
2345
|
+
* The timestamp of the last update to the SD-WAN configuration.
|
|
2346
|
+
*/
|
|
2347
|
+
updatedAt?: number;
|
|
2348
|
+
/**
|
|
2349
|
+
* List of hubs in SD-WAN configuration
|
|
2350
|
+
*/
|
|
2351
|
+
hubs?: Array<{
|
|
2352
|
+
/**
|
|
2353
|
+
* Unique identifier of the hub
|
|
2354
|
+
*/
|
|
2355
|
+
id?: string;
|
|
2356
|
+
hostId?: string;
|
|
2357
|
+
siteId?: string;
|
|
2358
|
+
name?: string;
|
|
2359
|
+
primaryWanStatus?: {
|
|
2360
|
+
/**
|
|
2361
|
+
* IP format: 10.0.0.1
|
|
2362
|
+
*/
|
|
2363
|
+
ip?: string;
|
|
2364
|
+
latency?: number | null;
|
|
2365
|
+
/**
|
|
2366
|
+
* If WAN experience issues
|
|
2367
|
+
*/
|
|
2368
|
+
internetIssues?: Array<{
|
|
2369
|
+
[key: string]: unknown;
|
|
2370
|
+
}>;
|
|
2371
|
+
wanId?: string;
|
|
2372
|
+
};
|
|
2373
|
+
secondaryWanStatus?: {
|
|
2374
|
+
/**
|
|
2375
|
+
* IP format: 10.0.0.1
|
|
2376
|
+
*/
|
|
2377
|
+
ip?: string;
|
|
2378
|
+
latency?: number | null;
|
|
2379
|
+
/**
|
|
2380
|
+
* If WAN experience issues
|
|
2381
|
+
*/
|
|
2382
|
+
internetIssues?: Array<{
|
|
2383
|
+
[key: string]: unknown;
|
|
2384
|
+
}>;
|
|
2385
|
+
wanId?: string;
|
|
2386
|
+
};
|
|
2387
|
+
errors?: Array<{
|
|
2388
|
+
[key: string]: unknown;
|
|
2389
|
+
}>;
|
|
2390
|
+
warnings?: Array<{
|
|
2391
|
+
[key: string]: unknown;
|
|
2392
|
+
}>;
|
|
2393
|
+
numberOfTunnelsUsedByOtherFeatures?: number;
|
|
2394
|
+
networks?: Array<{
|
|
2395
|
+
networkId?: string;
|
|
2396
|
+
name?: string;
|
|
2397
|
+
errors?: Array<{
|
|
2398
|
+
[key: string]: unknown;
|
|
2399
|
+
}>;
|
|
2400
|
+
warnings?: Array<{
|
|
2401
|
+
[key: string]: unknown;
|
|
2402
|
+
}>;
|
|
2403
|
+
}>;
|
|
2404
|
+
routes?: Array<{
|
|
2405
|
+
/**
|
|
2406
|
+
* subnet in CIDR format: 10.0.0.0/24
|
|
2407
|
+
*/
|
|
2408
|
+
routeValue?: string;
|
|
2409
|
+
errors?: Array<{
|
|
2410
|
+
[key: string]: unknown;
|
|
2411
|
+
}>;
|
|
2412
|
+
warnings?: Array<{
|
|
2413
|
+
[key: string]: unknown;
|
|
2414
|
+
}>;
|
|
2415
|
+
}>;
|
|
2416
|
+
/**
|
|
2417
|
+
* The current status of the hub configuration application.
|
|
2418
|
+
*/
|
|
2419
|
+
applyStatus?: [
|
|
2420
|
+
'ok',
|
|
2421
|
+
'creating',
|
|
2422
|
+
'updating',
|
|
2423
|
+
'removing',
|
|
2424
|
+
'createFailed',
|
|
2425
|
+
'updateFailed',
|
|
2426
|
+
'removeFailed'
|
|
2427
|
+
];
|
|
2428
|
+
}>;
|
|
2429
|
+
/**
|
|
2430
|
+
* A list of spokes associated with the SD-WAN config.
|
|
2431
|
+
*/
|
|
2432
|
+
spokes?: Array<{
|
|
2433
|
+
id?: string;
|
|
2434
|
+
hostId?: string;
|
|
2435
|
+
siteId?: string;
|
|
2436
|
+
name?: string;
|
|
2437
|
+
primaryWanStatus?: {
|
|
2438
|
+
/**
|
|
2439
|
+
* IP format: 10.0.0.1
|
|
2440
|
+
*/
|
|
2441
|
+
ip?: string;
|
|
2442
|
+
latency?: number | null;
|
|
2443
|
+
/**
|
|
2444
|
+
* If WAN experience issues
|
|
2445
|
+
*/
|
|
2446
|
+
internetIssues?: Array<{
|
|
2447
|
+
[key: string]: unknown;
|
|
2448
|
+
}>;
|
|
2449
|
+
wanId?: string;
|
|
2450
|
+
};
|
|
2451
|
+
secondaryWanStatus?: {
|
|
2452
|
+
/**
|
|
2453
|
+
* IP format: 10.0.0.1
|
|
2454
|
+
*/
|
|
2455
|
+
ip?: string;
|
|
2456
|
+
latency?: number | null;
|
|
2457
|
+
/**
|
|
2458
|
+
* If WAN experience issues
|
|
2459
|
+
*/
|
|
2460
|
+
internetIssues?: Array<{
|
|
2461
|
+
[key: string]: unknown;
|
|
2462
|
+
}>;
|
|
2463
|
+
wanId?: string;
|
|
2464
|
+
};
|
|
2465
|
+
errors?: Array<{
|
|
2466
|
+
[key: string]: unknown;
|
|
2467
|
+
}>;
|
|
2468
|
+
warnings?: Array<{
|
|
2469
|
+
[key: string]: unknown;
|
|
2470
|
+
}>;
|
|
2471
|
+
numberOfTunnelsUsedByOtherFeatures?: number;
|
|
2472
|
+
networks?: Array<{
|
|
2473
|
+
networkId?: string;
|
|
2474
|
+
name?: string;
|
|
2475
|
+
/**
|
|
2476
|
+
* A list of error messages related to the network, if any.
|
|
2477
|
+
*/
|
|
2478
|
+
errors?: Array<{
|
|
2479
|
+
[key: string]: unknown;
|
|
2480
|
+
}>;
|
|
2481
|
+
/**
|
|
2482
|
+
* A list of warning messages related to the network, if any.
|
|
2483
|
+
*/
|
|
2484
|
+
warnings?: Array<{
|
|
2485
|
+
[key: string]: unknown;
|
|
2486
|
+
}>;
|
|
2487
|
+
}>;
|
|
2488
|
+
routes?: Array<{
|
|
2489
|
+
/**
|
|
2490
|
+
* subnet in CIDR format: 10.0.0.0/24
|
|
2491
|
+
*/
|
|
2492
|
+
routeValue?: string;
|
|
2493
|
+
errors?: Array<{
|
|
2494
|
+
[key: string]: unknown;
|
|
2495
|
+
}>;
|
|
2496
|
+
warnings?: Array<{
|
|
2497
|
+
[key: string]: unknown;
|
|
2498
|
+
}>;
|
|
2499
|
+
}>;
|
|
2500
|
+
connections?: Array<{
|
|
2501
|
+
hubId?: string;
|
|
2502
|
+
tunnels?: Array<{
|
|
2503
|
+
spokeWanId?: string;
|
|
2504
|
+
hubWanId?: string;
|
|
2505
|
+
/**
|
|
2506
|
+
* The current status of the tunnel connection.
|
|
2507
|
+
*/
|
|
2508
|
+
status?: [
|
|
2509
|
+
'connected',
|
|
2510
|
+
'disconnected',
|
|
2511
|
+
'pending'
|
|
2512
|
+
];
|
|
2513
|
+
}>;
|
|
2514
|
+
}>;
|
|
2515
|
+
/**
|
|
2516
|
+
* The current status of the hub configuration application.
|
|
2517
|
+
*/
|
|
2518
|
+
applyStatus?: [
|
|
2519
|
+
'ok',
|
|
2520
|
+
'creating',
|
|
2521
|
+
'updating',
|
|
2522
|
+
'removing',
|
|
2523
|
+
'createFailed',
|
|
2524
|
+
'updateFailed',
|
|
2525
|
+
'removeFailed'
|
|
2526
|
+
];
|
|
2527
|
+
}>;
|
|
2528
|
+
/**
|
|
2529
|
+
* The timestamp of the last generation of the SD-WAN configuration.
|
|
2530
|
+
*/
|
|
2531
|
+
lastGeneratedAt?: number;
|
|
2532
|
+
/**
|
|
2533
|
+
* The status of the configuration generation process.
|
|
2534
|
+
*/
|
|
2535
|
+
generateStatus?: [
|
|
2536
|
+
'OK',
|
|
2537
|
+
'GENERATING',
|
|
2538
|
+
'GENERATE_FAILED'
|
|
2539
|
+
];
|
|
2540
|
+
/**
|
|
2541
|
+
* A list of error messages related to the configuration, if any.
|
|
2542
|
+
*/
|
|
2543
|
+
errors?: Array<{
|
|
2544
|
+
[key: string]: unknown;
|
|
2545
|
+
}>;
|
|
2546
|
+
/**
|
|
2547
|
+
* A list of warning messages related to the configuration, if any.
|
|
2548
|
+
*/
|
|
2549
|
+
warnings?: Array<{
|
|
2550
|
+
[key: string]: unknown;
|
|
2551
|
+
}>;
|
|
2552
|
+
} | null;
|
|
2553
|
+
/**
|
|
2554
|
+
* HTTP status code
|
|
2555
|
+
*/
|
|
2556
|
+
httpStatusCode?: number;
|
|
2557
|
+
/**
|
|
2558
|
+
* Request trace identifier
|
|
2559
|
+
*/
|
|
2560
|
+
traceId?: string;
|
|
2561
|
+
};
|
|
2562
|
+
};
|
|
2563
|
+
export type GetSdWanConfigStatusResponse = GetSdWanConfigStatusResponses[keyof GetSdWanConfigStatusResponses];
|
|
2564
|
+
export type ListSitesData = {
|
|
2565
|
+
body?: never;
|
|
2566
|
+
path?: never;
|
|
2567
|
+
query?: {
|
|
2568
|
+
/**
|
|
2569
|
+
* Number of items to return per page
|
|
2570
|
+
*/
|
|
2571
|
+
pageSize?: string;
|
|
2572
|
+
/**
|
|
2573
|
+
* Token for pagination to retrieve the next set of results
|
|
2574
|
+
*/
|
|
2575
|
+
nextToken?: string;
|
|
2576
|
+
};
|
|
2577
|
+
url: '/v1/sites';
|
|
2578
|
+
};
|
|
2579
|
+
export type ListSitesErrors = {
|
|
2580
|
+
/**
|
|
2581
|
+
* 401
|
|
2582
|
+
*/
|
|
2583
|
+
401: {
|
|
2584
|
+
/**
|
|
2585
|
+
* Error code from upstream
|
|
2586
|
+
*/
|
|
2587
|
+
code?: unknown;
|
|
2588
|
+
/**
|
|
2589
|
+
* HTTP status code
|
|
2590
|
+
*/
|
|
2591
|
+
httpStatusCode?: number;
|
|
2592
|
+
/**
|
|
2593
|
+
* Error message
|
|
2594
|
+
*/
|
|
2595
|
+
message?: string;
|
|
2596
|
+
/**
|
|
2597
|
+
* Request trace identifier
|
|
2598
|
+
*/
|
|
2599
|
+
traceId?: string;
|
|
2600
|
+
};
|
|
2601
|
+
/**
|
|
2602
|
+
* 429
|
|
2603
|
+
*/
|
|
2604
|
+
429: {
|
|
2605
|
+
/**
|
|
2606
|
+
* Error code from upstream
|
|
2607
|
+
*/
|
|
2608
|
+
code?: unknown;
|
|
2609
|
+
/**
|
|
2610
|
+
* HTTP status code
|
|
2611
|
+
*/
|
|
2612
|
+
httpStatusCode?: number;
|
|
2613
|
+
/**
|
|
2614
|
+
* Error message
|
|
2615
|
+
*/
|
|
2616
|
+
message?: string;
|
|
2617
|
+
/**
|
|
2618
|
+
* Request trace identifier
|
|
2619
|
+
*/
|
|
2620
|
+
traceId?: string;
|
|
2621
|
+
};
|
|
2622
|
+
/**
|
|
2623
|
+
* 500
|
|
2624
|
+
*/
|
|
2625
|
+
500: {
|
|
2626
|
+
/**
|
|
2627
|
+
* Error code from upstream
|
|
2628
|
+
*/
|
|
2629
|
+
code?: unknown;
|
|
2630
|
+
/**
|
|
2631
|
+
* HTTP status code
|
|
2632
|
+
*/
|
|
2633
|
+
httpStatusCode?: number;
|
|
2634
|
+
/**
|
|
2635
|
+
* Error message
|
|
2636
|
+
*/
|
|
2637
|
+
message?: string;
|
|
2638
|
+
/**
|
|
2639
|
+
* Request trace identifier
|
|
2640
|
+
*/
|
|
2641
|
+
traceId?: string;
|
|
2642
|
+
};
|
|
2643
|
+
/**
|
|
2644
|
+
* 502
|
|
2645
|
+
*/
|
|
2646
|
+
502: {
|
|
2647
|
+
/**
|
|
2648
|
+
* Error code from upstream
|
|
2649
|
+
*/
|
|
2650
|
+
code?: unknown;
|
|
2651
|
+
/**
|
|
2652
|
+
* HTTP status code
|
|
2653
|
+
*/
|
|
2654
|
+
httpStatusCode?: number;
|
|
2655
|
+
/**
|
|
2656
|
+
* Error message
|
|
2657
|
+
*/
|
|
2658
|
+
message?: string;
|
|
2659
|
+
/**
|
|
2660
|
+
* Request trace identifier
|
|
2661
|
+
*/
|
|
2662
|
+
traceId?: string;
|
|
2663
|
+
};
|
|
2664
|
+
};
|
|
2665
|
+
export type ListSitesError = ListSitesErrors[keyof ListSitesErrors];
|
|
2666
|
+
export type ListSitesResponses = {
|
|
2667
|
+
/**
|
|
2668
|
+
* 200
|
|
2669
|
+
*/
|
|
2670
|
+
200: {
|
|
2671
|
+
/**
|
|
2672
|
+
* Error code from upstream
|
|
2673
|
+
*/
|
|
2674
|
+
code?: unknown;
|
|
2675
|
+
/**
|
|
2676
|
+
* Generic response data, specific schema depends on the endpoint
|
|
2677
|
+
*/
|
|
2678
|
+
data?: Array<{
|
|
2679
|
+
/**
|
|
2680
|
+
* Unique identifier of the site
|
|
2681
|
+
*/
|
|
2682
|
+
siteId?: string;
|
|
2683
|
+
/**
|
|
2684
|
+
* Unique identifier of the host device managing this site
|
|
2685
|
+
*/
|
|
2686
|
+
hostId?: string;
|
|
2687
|
+
/**
|
|
2688
|
+
* Site metadata including name, description, timezone, and gateway MAC address. Structure may vary depending on the UniFi Network version
|
|
2689
|
+
*/
|
|
2690
|
+
meta?: unknown;
|
|
2691
|
+
/**
|
|
2692
|
+
* Site statistics including device counts, client counts, and network performance metrics. Structure may vary depending on the UniFi Network version
|
|
2693
|
+
*/
|
|
2694
|
+
statistics?: unknown;
|
|
2695
|
+
/**
|
|
2696
|
+
* Permission level of the current user for this site (admin, readonly, etc.)
|
|
2697
|
+
*/
|
|
2698
|
+
permission?: string;
|
|
2699
|
+
/**
|
|
2700
|
+
* Indicates if the current user is the owner of this site
|
|
2701
|
+
*/
|
|
2702
|
+
isOwner?: boolean;
|
|
2703
|
+
} | null>;
|
|
2704
|
+
/**
|
|
2705
|
+
* HTTP status code
|
|
2706
|
+
*/
|
|
2707
|
+
httpStatusCode?: number;
|
|
2708
|
+
/**
|
|
2709
|
+
* Request trace identifier
|
|
2710
|
+
*/
|
|
2711
|
+
traceId?: string;
|
|
2712
|
+
/**
|
|
2713
|
+
* Pagination token for fetching the next set of results
|
|
2714
|
+
*/
|
|
2715
|
+
nextToken?: string;
|
|
2716
|
+
};
|
|
2717
|
+
};
|
|
2718
|
+
export type ListSitesResponse = ListSitesResponses[keyof ListSitesResponses];
|