@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.
Files changed (31) hide show
  1. package/README.md +149 -2
  2. package/dist/generated/client/client.gen.d.ts +2 -0
  3. package/dist/generated/client/index.d.ts +10 -0
  4. package/dist/generated/client/types.gen.d.ts +120 -0
  5. package/dist/generated/client/utils.gen.d.ts +37 -0
  6. package/dist/generated/client.gen.d.ts +12 -0
  7. package/dist/generated/core/auth.gen.d.ts +25 -0
  8. package/dist/generated/core/bodySerializer.gen.d.ts +25 -0
  9. package/dist/generated/core/params.gen.d.ts +43 -0
  10. package/dist/generated/core/pathSerializer.gen.d.ts +33 -0
  11. package/dist/generated/core/queryKeySerializer.gen.d.ts +18 -0
  12. package/dist/generated/core/serverSentEvents.gen.d.ts +71 -0
  13. package/dist/generated/core/types.gen.d.ts +83 -0
  14. package/dist/generated/core/utils.gen.d.ts +19 -0
  15. package/dist/generated/index.d.ts +2 -0
  16. package/dist/generated/sdk.gen.d.ts +99 -0
  17. package/dist/generated/types.gen.d.ts +2718 -0
  18. package/dist/index.d.ts +6 -0
  19. package/dist/index.js +6 -0
  20. package/dist/shared/client.d.ts +26 -0
  21. package/dist/shared/errors.d.ts +47 -0
  22. package/dist/shared/pagination.d.ts +18 -0
  23. package/dist/site-manager/client.d.ts +32 -0
  24. package/dist/site-manager/index.d.ts +64 -0
  25. package/dist/site-manager/resources/connector.d.ts +107 -0
  26. package/dist/site-manager/resources/devices.d.ts +36 -0
  27. package/dist/site-manager/resources/hosts.d.ts +41 -0
  28. package/dist/site-manager/resources/ispMetrics.d.ts +48 -0
  29. package/dist/site-manager/resources/sdWan.d.ts +27 -0
  30. package/dist/site-manager/resources/sites.d.ts +34 -0
  31. 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];