@alicloud/cloudsso20210515 1.0.0 → 1.0.1
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/LICENSE +13 -0
- package/README.md +25 -0
- package/dist/client.d.ts +234 -0
- package/dist/client.js +1083 -305
- package/dist/client.js.map +1 -1
- package/package.json +4 -4
- package/src/client.ts +1406 -313
package/dist/client.js
CHANGED
|
@@ -62,12 +62,14 @@ class AddExternalSAMLIdPCertificateResponse extends $tea.Model {
|
|
|
62
62
|
static names() {
|
|
63
63
|
return {
|
|
64
64
|
headers: 'headers',
|
|
65
|
+
statusCode: 'statusCode',
|
|
65
66
|
body: 'body',
|
|
66
67
|
};
|
|
67
68
|
}
|
|
68
69
|
static types() {
|
|
69
70
|
return {
|
|
70
71
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
72
|
+
statusCode: 'number',
|
|
71
73
|
body: AddExternalSAMLIdPCertificateResponseBody,
|
|
72
74
|
};
|
|
73
75
|
}
|
|
@@ -120,12 +122,14 @@ class AddPermissionPolicyToAccessConfigurationResponse extends $tea.Model {
|
|
|
120
122
|
static names() {
|
|
121
123
|
return {
|
|
122
124
|
headers: 'headers',
|
|
125
|
+
statusCode: 'statusCode',
|
|
123
126
|
body: 'body',
|
|
124
127
|
};
|
|
125
128
|
}
|
|
126
129
|
static types() {
|
|
127
130
|
return {
|
|
128
131
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
132
|
+
statusCode: 'number',
|
|
129
133
|
body: AddPermissionPolicyToAccessConfigurationResponseBody,
|
|
130
134
|
};
|
|
131
135
|
}
|
|
@@ -174,12 +178,14 @@ class AddUserToGroupResponse extends $tea.Model {
|
|
|
174
178
|
static names() {
|
|
175
179
|
return {
|
|
176
180
|
headers: 'headers',
|
|
181
|
+
statusCode: 'statusCode',
|
|
177
182
|
body: 'body',
|
|
178
183
|
};
|
|
179
184
|
}
|
|
180
185
|
static types() {
|
|
181
186
|
return {
|
|
182
187
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
188
|
+
statusCode: 'number',
|
|
183
189
|
body: AddUserToGroupResponseBody,
|
|
184
190
|
};
|
|
185
191
|
}
|
|
@@ -224,12 +230,14 @@ class ClearExternalSAMLIdentityProviderResponse extends $tea.Model {
|
|
|
224
230
|
static names() {
|
|
225
231
|
return {
|
|
226
232
|
headers: 'headers',
|
|
233
|
+
statusCode: 'statusCode',
|
|
227
234
|
body: 'body',
|
|
228
235
|
};
|
|
229
236
|
}
|
|
230
237
|
static types() {
|
|
231
238
|
return {
|
|
232
239
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
240
|
+
statusCode: 'number',
|
|
233
241
|
body: ClearExternalSAMLIdentityProviderResponseBody,
|
|
234
242
|
};
|
|
235
243
|
}
|
|
@@ -286,12 +294,14 @@ class CreateAccessAssignmentResponse extends $tea.Model {
|
|
|
286
294
|
static names() {
|
|
287
295
|
return {
|
|
288
296
|
headers: 'headers',
|
|
297
|
+
statusCode: 'statusCode',
|
|
289
298
|
body: 'body',
|
|
290
299
|
};
|
|
291
300
|
}
|
|
292
301
|
static types() {
|
|
293
302
|
return {
|
|
294
303
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
304
|
+
statusCode: 'number',
|
|
295
305
|
body: CreateAccessAssignmentResponseBody,
|
|
296
306
|
};
|
|
297
307
|
}
|
|
@@ -346,12 +356,14 @@ class CreateAccessConfigurationResponse extends $tea.Model {
|
|
|
346
356
|
static names() {
|
|
347
357
|
return {
|
|
348
358
|
headers: 'headers',
|
|
359
|
+
statusCode: 'statusCode',
|
|
349
360
|
body: 'body',
|
|
350
361
|
};
|
|
351
362
|
}
|
|
352
363
|
static types() {
|
|
353
364
|
return {
|
|
354
365
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
366
|
+
statusCode: 'number',
|
|
355
367
|
body: CreateAccessConfigurationResponseBody,
|
|
356
368
|
};
|
|
357
369
|
}
|
|
@@ -398,12 +410,14 @@ class CreateDirectoryResponse extends $tea.Model {
|
|
|
398
410
|
static names() {
|
|
399
411
|
return {
|
|
400
412
|
headers: 'headers',
|
|
413
|
+
statusCode: 'statusCode',
|
|
401
414
|
body: 'body',
|
|
402
415
|
};
|
|
403
416
|
}
|
|
404
417
|
static types() {
|
|
405
418
|
return {
|
|
406
419
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
420
|
+
statusCode: 'number',
|
|
407
421
|
body: CreateDirectoryResponseBody,
|
|
408
422
|
};
|
|
409
423
|
}
|
|
@@ -454,12 +468,14 @@ class CreateGroupResponse extends $tea.Model {
|
|
|
454
468
|
static names() {
|
|
455
469
|
return {
|
|
456
470
|
headers: 'headers',
|
|
471
|
+
statusCode: 'statusCode',
|
|
457
472
|
body: 'body',
|
|
458
473
|
};
|
|
459
474
|
}
|
|
460
475
|
static types() {
|
|
461
476
|
return {
|
|
462
477
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
478
|
+
statusCode: 'number',
|
|
463
479
|
body: CreateGroupResponseBody,
|
|
464
480
|
};
|
|
465
481
|
}
|
|
@@ -506,12 +522,14 @@ class CreateSCIMServerCredentialResponse extends $tea.Model {
|
|
|
506
522
|
static names() {
|
|
507
523
|
return {
|
|
508
524
|
headers: 'headers',
|
|
525
|
+
statusCode: 'statusCode',
|
|
509
526
|
body: 'body',
|
|
510
527
|
};
|
|
511
528
|
}
|
|
512
529
|
static types() {
|
|
513
530
|
return {
|
|
514
531
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
532
|
+
statusCode: 'number',
|
|
515
533
|
body: CreateSCIMServerCredentialResponseBody,
|
|
516
534
|
};
|
|
517
535
|
}
|
|
@@ -572,12 +590,14 @@ class CreateUserResponse extends $tea.Model {
|
|
|
572
590
|
static names() {
|
|
573
591
|
return {
|
|
574
592
|
headers: 'headers',
|
|
593
|
+
statusCode: 'statusCode',
|
|
575
594
|
body: 'body',
|
|
576
595
|
};
|
|
577
596
|
}
|
|
578
597
|
static types() {
|
|
579
598
|
return {
|
|
580
599
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
600
|
+
statusCode: 'number',
|
|
581
601
|
body: CreateUserResponseBody,
|
|
582
602
|
};
|
|
583
603
|
}
|
|
@@ -636,12 +656,14 @@ class DeleteAccessAssignmentResponse extends $tea.Model {
|
|
|
636
656
|
static names() {
|
|
637
657
|
return {
|
|
638
658
|
headers: 'headers',
|
|
659
|
+
statusCode: 'statusCode',
|
|
639
660
|
body: 'body',
|
|
640
661
|
};
|
|
641
662
|
}
|
|
642
663
|
static types() {
|
|
643
664
|
return {
|
|
644
665
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
666
|
+
statusCode: 'number',
|
|
645
667
|
body: DeleteAccessAssignmentResponseBody,
|
|
646
668
|
};
|
|
647
669
|
}
|
|
@@ -690,12 +712,14 @@ class DeleteAccessConfigurationResponse extends $tea.Model {
|
|
|
690
712
|
static names() {
|
|
691
713
|
return {
|
|
692
714
|
headers: 'headers',
|
|
715
|
+
statusCode: 'statusCode',
|
|
693
716
|
body: 'body',
|
|
694
717
|
};
|
|
695
718
|
}
|
|
696
719
|
static types() {
|
|
697
720
|
return {
|
|
698
721
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
722
|
+
statusCode: 'number',
|
|
699
723
|
body: DeleteAccessConfigurationResponseBody,
|
|
700
724
|
};
|
|
701
725
|
}
|
|
@@ -740,12 +764,14 @@ class DeleteDirectoryResponse extends $tea.Model {
|
|
|
740
764
|
static names() {
|
|
741
765
|
return {
|
|
742
766
|
headers: 'headers',
|
|
767
|
+
statusCode: 'statusCode',
|
|
743
768
|
body: 'body',
|
|
744
769
|
};
|
|
745
770
|
}
|
|
746
771
|
static types() {
|
|
747
772
|
return {
|
|
748
773
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
774
|
+
statusCode: 'number',
|
|
749
775
|
body: DeleteDirectoryResponseBody,
|
|
750
776
|
};
|
|
751
777
|
}
|
|
@@ -792,12 +818,14 @@ class DeleteGroupResponse extends $tea.Model {
|
|
|
792
818
|
static names() {
|
|
793
819
|
return {
|
|
794
820
|
headers: 'headers',
|
|
821
|
+
statusCode: 'statusCode',
|
|
795
822
|
body: 'body',
|
|
796
823
|
};
|
|
797
824
|
}
|
|
798
825
|
static types() {
|
|
799
826
|
return {
|
|
800
827
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
828
|
+
statusCode: 'number',
|
|
801
829
|
body: DeleteGroupResponseBody,
|
|
802
830
|
};
|
|
803
831
|
}
|
|
@@ -846,12 +874,14 @@ class DeleteMFADeviceForUserResponse extends $tea.Model {
|
|
|
846
874
|
static names() {
|
|
847
875
|
return {
|
|
848
876
|
headers: 'headers',
|
|
877
|
+
statusCode: 'statusCode',
|
|
849
878
|
body: 'body',
|
|
850
879
|
};
|
|
851
880
|
}
|
|
852
881
|
static types() {
|
|
853
882
|
return {
|
|
854
883
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
884
|
+
statusCode: 'number',
|
|
855
885
|
body: DeleteMFADeviceForUserResponseBody,
|
|
856
886
|
};
|
|
857
887
|
}
|
|
@@ -898,12 +928,14 @@ class DeleteSCIMServerCredentialResponse extends $tea.Model {
|
|
|
898
928
|
static names() {
|
|
899
929
|
return {
|
|
900
930
|
headers: 'headers',
|
|
931
|
+
statusCode: 'statusCode',
|
|
901
932
|
body: 'body',
|
|
902
933
|
};
|
|
903
934
|
}
|
|
904
935
|
static types() {
|
|
905
936
|
return {
|
|
906
937
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
938
|
+
statusCode: 'number',
|
|
907
939
|
body: DeleteSCIMServerCredentialResponseBody,
|
|
908
940
|
};
|
|
909
941
|
}
|
|
@@ -950,12 +982,14 @@ class DeleteUserResponse extends $tea.Model {
|
|
|
950
982
|
static names() {
|
|
951
983
|
return {
|
|
952
984
|
headers: 'headers',
|
|
985
|
+
statusCode: 'statusCode',
|
|
953
986
|
body: 'body',
|
|
954
987
|
};
|
|
955
988
|
}
|
|
956
989
|
static types() {
|
|
957
990
|
return {
|
|
958
991
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
992
|
+
statusCode: 'number',
|
|
959
993
|
body: DeleteUserResponseBody,
|
|
960
994
|
};
|
|
961
995
|
}
|
|
@@ -1008,12 +1042,14 @@ class DeprovisionAccessConfigurationResponse extends $tea.Model {
|
|
|
1008
1042
|
static names() {
|
|
1009
1043
|
return {
|
|
1010
1044
|
headers: 'headers',
|
|
1045
|
+
statusCode: 'statusCode',
|
|
1011
1046
|
body: 'body',
|
|
1012
1047
|
};
|
|
1013
1048
|
}
|
|
1014
1049
|
static types() {
|
|
1015
1050
|
return {
|
|
1016
1051
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1052
|
+
statusCode: 'number',
|
|
1017
1053
|
body: DeprovisionAccessConfigurationResponseBody,
|
|
1018
1054
|
};
|
|
1019
1055
|
}
|
|
@@ -1042,12 +1078,14 @@ class DisableServiceResponse extends $tea.Model {
|
|
|
1042
1078
|
static names() {
|
|
1043
1079
|
return {
|
|
1044
1080
|
headers: 'headers',
|
|
1081
|
+
statusCode: 'statusCode',
|
|
1045
1082
|
body: 'body',
|
|
1046
1083
|
};
|
|
1047
1084
|
}
|
|
1048
1085
|
static types() {
|
|
1049
1086
|
return {
|
|
1050
1087
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1088
|
+
statusCode: 'number',
|
|
1051
1089
|
body: DisableServiceResponseBody,
|
|
1052
1090
|
};
|
|
1053
1091
|
}
|
|
@@ -1076,12 +1114,14 @@ class EnableServiceResponse extends $tea.Model {
|
|
|
1076
1114
|
static names() {
|
|
1077
1115
|
return {
|
|
1078
1116
|
headers: 'headers',
|
|
1117
|
+
statusCode: 'statusCode',
|
|
1079
1118
|
body: 'body',
|
|
1080
1119
|
};
|
|
1081
1120
|
}
|
|
1082
1121
|
static types() {
|
|
1083
1122
|
return {
|
|
1084
1123
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1124
|
+
statusCode: 'number',
|
|
1085
1125
|
body: EnableServiceResponseBody,
|
|
1086
1126
|
};
|
|
1087
1127
|
}
|
|
@@ -1130,12 +1170,14 @@ class GetAccessConfigurationResponse extends $tea.Model {
|
|
|
1130
1170
|
static names() {
|
|
1131
1171
|
return {
|
|
1132
1172
|
headers: 'headers',
|
|
1173
|
+
statusCode: 'statusCode',
|
|
1133
1174
|
body: 'body',
|
|
1134
1175
|
};
|
|
1135
1176
|
}
|
|
1136
1177
|
static types() {
|
|
1137
1178
|
return {
|
|
1138
1179
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1180
|
+
statusCode: 'number',
|
|
1139
1181
|
body: GetAccessConfigurationResponseBody,
|
|
1140
1182
|
};
|
|
1141
1183
|
}
|
|
@@ -1182,12 +1224,14 @@ class GetDirectoryResponse extends $tea.Model {
|
|
|
1182
1224
|
static names() {
|
|
1183
1225
|
return {
|
|
1184
1226
|
headers: 'headers',
|
|
1227
|
+
statusCode: 'statusCode',
|
|
1185
1228
|
body: 'body',
|
|
1186
1229
|
};
|
|
1187
1230
|
}
|
|
1188
1231
|
static types() {
|
|
1189
1232
|
return {
|
|
1190
1233
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1234
|
+
statusCode: 'number',
|
|
1191
1235
|
body: GetDirectoryResponseBody,
|
|
1192
1236
|
};
|
|
1193
1237
|
}
|
|
@@ -1234,12 +1278,14 @@ class GetDirectorySAMLServiceProviderInfoResponse extends $tea.Model {
|
|
|
1234
1278
|
static names() {
|
|
1235
1279
|
return {
|
|
1236
1280
|
headers: 'headers',
|
|
1281
|
+
statusCode: 'statusCode',
|
|
1237
1282
|
body: 'body',
|
|
1238
1283
|
};
|
|
1239
1284
|
}
|
|
1240
1285
|
static types() {
|
|
1241
1286
|
return {
|
|
1242
1287
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1288
|
+
statusCode: 'number',
|
|
1243
1289
|
body: GetDirectorySAMLServiceProviderInfoResponseBody,
|
|
1244
1290
|
};
|
|
1245
1291
|
}
|
|
@@ -1286,12 +1332,14 @@ class GetDirectoryStatisticsResponse extends $tea.Model {
|
|
|
1286
1332
|
static names() {
|
|
1287
1333
|
return {
|
|
1288
1334
|
headers: 'headers',
|
|
1335
|
+
statusCode: 'statusCode',
|
|
1289
1336
|
body: 'body',
|
|
1290
1337
|
};
|
|
1291
1338
|
}
|
|
1292
1339
|
static types() {
|
|
1293
1340
|
return {
|
|
1294
1341
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1342
|
+
statusCode: 'number',
|
|
1295
1343
|
body: GetDirectoryStatisticsResponseBody,
|
|
1296
1344
|
};
|
|
1297
1345
|
}
|
|
@@ -1338,12 +1386,14 @@ class GetExternalSAMLIdentityProviderResponse extends $tea.Model {
|
|
|
1338
1386
|
static names() {
|
|
1339
1387
|
return {
|
|
1340
1388
|
headers: 'headers',
|
|
1389
|
+
statusCode: 'statusCode',
|
|
1341
1390
|
body: 'body',
|
|
1342
1391
|
};
|
|
1343
1392
|
}
|
|
1344
1393
|
static types() {
|
|
1345
1394
|
return {
|
|
1346
1395
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1396
|
+
statusCode: 'number',
|
|
1347
1397
|
body: GetExternalSAMLIdentityProviderResponseBody,
|
|
1348
1398
|
};
|
|
1349
1399
|
}
|
|
@@ -1392,17 +1442,73 @@ class GetGroupResponse extends $tea.Model {
|
|
|
1392
1442
|
static names() {
|
|
1393
1443
|
return {
|
|
1394
1444
|
headers: 'headers',
|
|
1445
|
+
statusCode: 'statusCode',
|
|
1395
1446
|
body: 'body',
|
|
1396
1447
|
};
|
|
1397
1448
|
}
|
|
1398
1449
|
static types() {
|
|
1399
1450
|
return {
|
|
1400
1451
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1452
|
+
statusCode: 'number',
|
|
1401
1453
|
body: GetGroupResponseBody,
|
|
1402
1454
|
};
|
|
1403
1455
|
}
|
|
1404
1456
|
}
|
|
1405
1457
|
exports.GetGroupResponse = GetGroupResponse;
|
|
1458
|
+
class GetMFAAuthenticationSettingsRequest extends $tea.Model {
|
|
1459
|
+
constructor(map) {
|
|
1460
|
+
super(map);
|
|
1461
|
+
}
|
|
1462
|
+
static names() {
|
|
1463
|
+
return {
|
|
1464
|
+
directoryId: 'DirectoryId',
|
|
1465
|
+
};
|
|
1466
|
+
}
|
|
1467
|
+
static types() {
|
|
1468
|
+
return {
|
|
1469
|
+
directoryId: 'string',
|
|
1470
|
+
};
|
|
1471
|
+
}
|
|
1472
|
+
}
|
|
1473
|
+
exports.GetMFAAuthenticationSettingsRequest = GetMFAAuthenticationSettingsRequest;
|
|
1474
|
+
class GetMFAAuthenticationSettingsResponseBody extends $tea.Model {
|
|
1475
|
+
constructor(map) {
|
|
1476
|
+
super(map);
|
|
1477
|
+
}
|
|
1478
|
+
static names() {
|
|
1479
|
+
return {
|
|
1480
|
+
MFAAuthenticationAdvanceSettings: 'MFAAuthenticationAdvanceSettings',
|
|
1481
|
+
requestId: 'RequestId',
|
|
1482
|
+
};
|
|
1483
|
+
}
|
|
1484
|
+
static types() {
|
|
1485
|
+
return {
|
|
1486
|
+
MFAAuthenticationAdvanceSettings: 'string',
|
|
1487
|
+
requestId: 'string',
|
|
1488
|
+
};
|
|
1489
|
+
}
|
|
1490
|
+
}
|
|
1491
|
+
exports.GetMFAAuthenticationSettingsResponseBody = GetMFAAuthenticationSettingsResponseBody;
|
|
1492
|
+
class GetMFAAuthenticationSettingsResponse extends $tea.Model {
|
|
1493
|
+
constructor(map) {
|
|
1494
|
+
super(map);
|
|
1495
|
+
}
|
|
1496
|
+
static names() {
|
|
1497
|
+
return {
|
|
1498
|
+
headers: 'headers',
|
|
1499
|
+
statusCode: 'statusCode',
|
|
1500
|
+
body: 'body',
|
|
1501
|
+
};
|
|
1502
|
+
}
|
|
1503
|
+
static types() {
|
|
1504
|
+
return {
|
|
1505
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1506
|
+
statusCode: 'number',
|
|
1507
|
+
body: GetMFAAuthenticationSettingsResponseBody,
|
|
1508
|
+
};
|
|
1509
|
+
}
|
|
1510
|
+
}
|
|
1511
|
+
exports.GetMFAAuthenticationSettingsResponse = GetMFAAuthenticationSettingsResponse;
|
|
1406
1512
|
class GetMFAAuthenticationStatusRequest extends $tea.Model {
|
|
1407
1513
|
constructor(map) {
|
|
1408
1514
|
super(map);
|
|
@@ -1444,12 +1550,14 @@ class GetMFAAuthenticationStatusResponse extends $tea.Model {
|
|
|
1444
1550
|
static names() {
|
|
1445
1551
|
return {
|
|
1446
1552
|
headers: 'headers',
|
|
1553
|
+
statusCode: 'statusCode',
|
|
1447
1554
|
body: 'body',
|
|
1448
1555
|
};
|
|
1449
1556
|
}
|
|
1450
1557
|
static types() {
|
|
1451
1558
|
return {
|
|
1452
1559
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1560
|
+
statusCode: 'number',
|
|
1453
1561
|
body: GetMFAAuthenticationStatusResponseBody,
|
|
1454
1562
|
};
|
|
1455
1563
|
}
|
|
@@ -1496,12 +1604,14 @@ class GetSCIMSynchronizationStatusResponse extends $tea.Model {
|
|
|
1496
1604
|
static names() {
|
|
1497
1605
|
return {
|
|
1498
1606
|
headers: 'headers',
|
|
1607
|
+
statusCode: 'statusCode',
|
|
1499
1608
|
body: 'body',
|
|
1500
1609
|
};
|
|
1501
1610
|
}
|
|
1502
1611
|
static types() {
|
|
1503
1612
|
return {
|
|
1504
1613
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1614
|
+
statusCode: 'number',
|
|
1505
1615
|
body: GetSCIMSynchronizationStatusResponseBody,
|
|
1506
1616
|
};
|
|
1507
1617
|
}
|
|
@@ -1532,12 +1642,14 @@ class GetServiceStatusResponse extends $tea.Model {
|
|
|
1532
1642
|
static names() {
|
|
1533
1643
|
return {
|
|
1534
1644
|
headers: 'headers',
|
|
1645
|
+
statusCode: 'statusCode',
|
|
1535
1646
|
body: 'body',
|
|
1536
1647
|
};
|
|
1537
1648
|
}
|
|
1538
1649
|
static types() {
|
|
1539
1650
|
return {
|
|
1540
1651
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1652
|
+
statusCode: 'number',
|
|
1541
1653
|
body: GetServiceStatusResponseBody,
|
|
1542
1654
|
};
|
|
1543
1655
|
}
|
|
@@ -1586,12 +1698,14 @@ class GetTaskResponse extends $tea.Model {
|
|
|
1586
1698
|
static names() {
|
|
1587
1699
|
return {
|
|
1588
1700
|
headers: 'headers',
|
|
1701
|
+
statusCode: 'statusCode',
|
|
1589
1702
|
body: 'body',
|
|
1590
1703
|
};
|
|
1591
1704
|
}
|
|
1592
1705
|
static types() {
|
|
1593
1706
|
return {
|
|
1594
1707
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1708
|
+
statusCode: 'number',
|
|
1595
1709
|
body: GetTaskResponseBody,
|
|
1596
1710
|
};
|
|
1597
1711
|
}
|
|
@@ -1640,12 +1754,14 @@ class GetTaskStatusResponse extends $tea.Model {
|
|
|
1640
1754
|
static names() {
|
|
1641
1755
|
return {
|
|
1642
1756
|
headers: 'headers',
|
|
1757
|
+
statusCode: 'statusCode',
|
|
1643
1758
|
body: 'body',
|
|
1644
1759
|
};
|
|
1645
1760
|
}
|
|
1646
1761
|
static types() {
|
|
1647
1762
|
return {
|
|
1648
1763
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1764
|
+
statusCode: 'number',
|
|
1649
1765
|
body: GetTaskStatusResponseBody,
|
|
1650
1766
|
};
|
|
1651
1767
|
}
|
|
@@ -1694,17 +1810,75 @@ class GetUserResponse extends $tea.Model {
|
|
|
1694
1810
|
static names() {
|
|
1695
1811
|
return {
|
|
1696
1812
|
headers: 'headers',
|
|
1813
|
+
statusCode: 'statusCode',
|
|
1697
1814
|
body: 'body',
|
|
1698
1815
|
};
|
|
1699
1816
|
}
|
|
1700
1817
|
static types() {
|
|
1701
1818
|
return {
|
|
1702
1819
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1820
|
+
statusCode: 'number',
|
|
1703
1821
|
body: GetUserResponseBody,
|
|
1704
1822
|
};
|
|
1705
1823
|
}
|
|
1706
1824
|
}
|
|
1707
1825
|
exports.GetUserResponse = GetUserResponse;
|
|
1826
|
+
class GetUserMFAAuthenticationSettingsRequest extends $tea.Model {
|
|
1827
|
+
constructor(map) {
|
|
1828
|
+
super(map);
|
|
1829
|
+
}
|
|
1830
|
+
static names() {
|
|
1831
|
+
return {
|
|
1832
|
+
directoryId: 'DirectoryId',
|
|
1833
|
+
userId: 'UserId',
|
|
1834
|
+
};
|
|
1835
|
+
}
|
|
1836
|
+
static types() {
|
|
1837
|
+
return {
|
|
1838
|
+
directoryId: 'string',
|
|
1839
|
+
userId: 'string',
|
|
1840
|
+
};
|
|
1841
|
+
}
|
|
1842
|
+
}
|
|
1843
|
+
exports.GetUserMFAAuthenticationSettingsRequest = GetUserMFAAuthenticationSettingsRequest;
|
|
1844
|
+
class GetUserMFAAuthenticationSettingsResponseBody extends $tea.Model {
|
|
1845
|
+
constructor(map) {
|
|
1846
|
+
super(map);
|
|
1847
|
+
}
|
|
1848
|
+
static names() {
|
|
1849
|
+
return {
|
|
1850
|
+
requestId: 'RequestId',
|
|
1851
|
+
userMFAAuthenticationSettings: 'UserMFAAuthenticationSettings',
|
|
1852
|
+
};
|
|
1853
|
+
}
|
|
1854
|
+
static types() {
|
|
1855
|
+
return {
|
|
1856
|
+
requestId: 'string',
|
|
1857
|
+
userMFAAuthenticationSettings: 'string',
|
|
1858
|
+
};
|
|
1859
|
+
}
|
|
1860
|
+
}
|
|
1861
|
+
exports.GetUserMFAAuthenticationSettingsResponseBody = GetUserMFAAuthenticationSettingsResponseBody;
|
|
1862
|
+
class GetUserMFAAuthenticationSettingsResponse extends $tea.Model {
|
|
1863
|
+
constructor(map) {
|
|
1864
|
+
super(map);
|
|
1865
|
+
}
|
|
1866
|
+
static names() {
|
|
1867
|
+
return {
|
|
1868
|
+
headers: 'headers',
|
|
1869
|
+
statusCode: 'statusCode',
|
|
1870
|
+
body: 'body',
|
|
1871
|
+
};
|
|
1872
|
+
}
|
|
1873
|
+
static types() {
|
|
1874
|
+
return {
|
|
1875
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1876
|
+
statusCode: 'number',
|
|
1877
|
+
body: GetUserMFAAuthenticationSettingsResponseBody,
|
|
1878
|
+
};
|
|
1879
|
+
}
|
|
1880
|
+
}
|
|
1881
|
+
exports.GetUserMFAAuthenticationSettingsResponse = GetUserMFAAuthenticationSettingsResponse;
|
|
1708
1882
|
class ListAccessAssignmentsRequest extends $tea.Model {
|
|
1709
1883
|
constructor(map) {
|
|
1710
1884
|
super(map);
|
|
@@ -1768,12 +1942,14 @@ class ListAccessAssignmentsResponse extends $tea.Model {
|
|
|
1768
1942
|
static names() {
|
|
1769
1943
|
return {
|
|
1770
1944
|
headers: 'headers',
|
|
1945
|
+
statusCode: 'statusCode',
|
|
1771
1946
|
body: 'body',
|
|
1772
1947
|
};
|
|
1773
1948
|
}
|
|
1774
1949
|
static types() {
|
|
1775
1950
|
return {
|
|
1776
1951
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1952
|
+
statusCode: 'number',
|
|
1777
1953
|
body: ListAccessAssignmentsResponseBody,
|
|
1778
1954
|
};
|
|
1779
1955
|
}
|
|
@@ -1840,12 +2016,14 @@ class ListAccessConfigurationProvisioningsResponse extends $tea.Model {
|
|
|
1840
2016
|
static names() {
|
|
1841
2017
|
return {
|
|
1842
2018
|
headers: 'headers',
|
|
2019
|
+
statusCode: 'statusCode',
|
|
1843
2020
|
body: 'body',
|
|
1844
2021
|
};
|
|
1845
2022
|
}
|
|
1846
2023
|
static types() {
|
|
1847
2024
|
return {
|
|
1848
2025
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2026
|
+
statusCode: 'number',
|
|
1849
2027
|
body: ListAccessConfigurationProvisioningsResponseBody,
|
|
1850
2028
|
};
|
|
1851
2029
|
}
|
|
@@ -1908,12 +2086,14 @@ class ListAccessConfigurationsResponse extends $tea.Model {
|
|
|
1908
2086
|
static names() {
|
|
1909
2087
|
return {
|
|
1910
2088
|
headers: 'headers',
|
|
2089
|
+
statusCode: 'statusCode',
|
|
1911
2090
|
body: 'body',
|
|
1912
2091
|
};
|
|
1913
2092
|
}
|
|
1914
2093
|
static types() {
|
|
1915
2094
|
return {
|
|
1916
2095
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2096
|
+
statusCode: 'number',
|
|
1917
2097
|
body: ListAccessConfigurationsResponseBody,
|
|
1918
2098
|
};
|
|
1919
2099
|
}
|
|
@@ -1946,12 +2126,14 @@ class ListDirectoriesResponse extends $tea.Model {
|
|
|
1946
2126
|
static names() {
|
|
1947
2127
|
return {
|
|
1948
2128
|
headers: 'headers',
|
|
2129
|
+
statusCode: 'statusCode',
|
|
1949
2130
|
body: 'body',
|
|
1950
2131
|
};
|
|
1951
2132
|
}
|
|
1952
2133
|
static types() {
|
|
1953
2134
|
return {
|
|
1954
2135
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2136
|
+
statusCode: 'number',
|
|
1955
2137
|
body: ListDirectoriesResponseBody,
|
|
1956
2138
|
};
|
|
1957
2139
|
}
|
|
@@ -2000,12 +2182,14 @@ class ListExternalSAMLIdPCertificatesResponse extends $tea.Model {
|
|
|
2000
2182
|
static names() {
|
|
2001
2183
|
return {
|
|
2002
2184
|
headers: 'headers',
|
|
2185
|
+
statusCode: 'statusCode',
|
|
2003
2186
|
body: 'body',
|
|
2004
2187
|
};
|
|
2005
2188
|
}
|
|
2006
2189
|
static types() {
|
|
2007
2190
|
return {
|
|
2008
2191
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2192
|
+
statusCode: 'number',
|
|
2009
2193
|
body: ListExternalSAMLIdPCertificatesResponseBody,
|
|
2010
2194
|
};
|
|
2011
2195
|
}
|
|
@@ -2066,12 +2250,14 @@ class ListGroupMembersResponse extends $tea.Model {
|
|
|
2066
2250
|
static names() {
|
|
2067
2251
|
return {
|
|
2068
2252
|
headers: 'headers',
|
|
2253
|
+
statusCode: 'statusCode',
|
|
2069
2254
|
body: 'body',
|
|
2070
2255
|
};
|
|
2071
2256
|
}
|
|
2072
2257
|
static types() {
|
|
2073
2258
|
return {
|
|
2074
2259
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2260
|
+
statusCode: 'number',
|
|
2075
2261
|
body: ListGroupMembersResponseBody,
|
|
2076
2262
|
};
|
|
2077
2263
|
}
|
|
@@ -2134,12 +2320,14 @@ class ListGroupsResponse extends $tea.Model {
|
|
|
2134
2320
|
static names() {
|
|
2135
2321
|
return {
|
|
2136
2322
|
headers: 'headers',
|
|
2323
|
+
statusCode: 'statusCode',
|
|
2137
2324
|
body: 'body',
|
|
2138
2325
|
};
|
|
2139
2326
|
}
|
|
2140
2327
|
static types() {
|
|
2141
2328
|
return {
|
|
2142
2329
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2330
|
+
statusCode: 'number',
|
|
2143
2331
|
body: ListGroupsResponseBody,
|
|
2144
2332
|
};
|
|
2145
2333
|
}
|
|
@@ -2200,12 +2388,14 @@ class ListJoinedGroupsForUserResponse extends $tea.Model {
|
|
|
2200
2388
|
static names() {
|
|
2201
2389
|
return {
|
|
2202
2390
|
headers: 'headers',
|
|
2391
|
+
statusCode: 'statusCode',
|
|
2203
2392
|
body: 'body',
|
|
2204
2393
|
};
|
|
2205
2394
|
}
|
|
2206
2395
|
static types() {
|
|
2207
2396
|
return {
|
|
2208
2397
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2398
|
+
statusCode: 'number',
|
|
2209
2399
|
body: ListJoinedGroupsForUserResponseBody,
|
|
2210
2400
|
};
|
|
2211
2401
|
}
|
|
@@ -2256,12 +2446,14 @@ class ListMFADevicesForUserResponse extends $tea.Model {
|
|
|
2256
2446
|
static names() {
|
|
2257
2447
|
return {
|
|
2258
2448
|
headers: 'headers',
|
|
2449
|
+
statusCode: 'statusCode',
|
|
2259
2450
|
body: 'body',
|
|
2260
2451
|
};
|
|
2261
2452
|
}
|
|
2262
2453
|
static types() {
|
|
2263
2454
|
return {
|
|
2264
2455
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2456
|
+
statusCode: 'number',
|
|
2265
2457
|
body: ListMFADevicesForUserResponseBody,
|
|
2266
2458
|
};
|
|
2267
2459
|
}
|
|
@@ -2314,12 +2506,14 @@ class ListPermissionPoliciesInAccessConfigurationResponse extends $tea.Model {
|
|
|
2314
2506
|
static names() {
|
|
2315
2507
|
return {
|
|
2316
2508
|
headers: 'headers',
|
|
2509
|
+
statusCode: 'statusCode',
|
|
2317
2510
|
body: 'body',
|
|
2318
2511
|
};
|
|
2319
2512
|
}
|
|
2320
2513
|
static types() {
|
|
2321
2514
|
return {
|
|
2322
2515
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2516
|
+
statusCode: 'number',
|
|
2323
2517
|
body: ListPermissionPoliciesInAccessConfigurationResponseBody,
|
|
2324
2518
|
};
|
|
2325
2519
|
}
|
|
@@ -2368,12 +2562,14 @@ class ListSCIMServerCredentialsResponse extends $tea.Model {
|
|
|
2368
2562
|
static names() {
|
|
2369
2563
|
return {
|
|
2370
2564
|
headers: 'headers',
|
|
2565
|
+
statusCode: 'statusCode',
|
|
2371
2566
|
body: 'body',
|
|
2372
2567
|
};
|
|
2373
2568
|
}
|
|
2374
2569
|
static types() {
|
|
2375
2570
|
return {
|
|
2376
2571
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2572
|
+
statusCode: 'number',
|
|
2377
2573
|
body: ListSCIMServerCredentialsResponseBody,
|
|
2378
2574
|
};
|
|
2379
2575
|
}
|
|
@@ -2448,12 +2644,14 @@ class ListTasksResponse extends $tea.Model {
|
|
|
2448
2644
|
static names() {
|
|
2449
2645
|
return {
|
|
2450
2646
|
headers: 'headers',
|
|
2647
|
+
statusCode: 'statusCode',
|
|
2451
2648
|
body: 'body',
|
|
2452
2649
|
};
|
|
2453
2650
|
}
|
|
2454
2651
|
static types() {
|
|
2455
2652
|
return {
|
|
2456
2653
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2654
|
+
statusCode: 'number',
|
|
2457
2655
|
body: ListTasksResponseBody,
|
|
2458
2656
|
};
|
|
2459
2657
|
}
|
|
@@ -2518,12 +2716,14 @@ class ListUsersResponse extends $tea.Model {
|
|
|
2518
2716
|
static names() {
|
|
2519
2717
|
return {
|
|
2520
2718
|
headers: 'headers',
|
|
2719
|
+
statusCode: 'statusCode',
|
|
2521
2720
|
body: 'body',
|
|
2522
2721
|
};
|
|
2523
2722
|
}
|
|
2524
2723
|
static types() {
|
|
2525
2724
|
return {
|
|
2526
2725
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2726
|
+
statusCode: 'number',
|
|
2527
2727
|
body: ListUsersResponseBody,
|
|
2528
2728
|
};
|
|
2529
2729
|
}
|
|
@@ -2576,12 +2776,14 @@ class ProvisionAccessConfigurationResponse extends $tea.Model {
|
|
|
2576
2776
|
static names() {
|
|
2577
2777
|
return {
|
|
2578
2778
|
headers: 'headers',
|
|
2779
|
+
statusCode: 'statusCode',
|
|
2579
2780
|
body: 'body',
|
|
2580
2781
|
};
|
|
2581
2782
|
}
|
|
2582
2783
|
static types() {
|
|
2583
2784
|
return {
|
|
2584
2785
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2786
|
+
statusCode: 'number',
|
|
2585
2787
|
body: ProvisionAccessConfigurationResponseBody,
|
|
2586
2788
|
};
|
|
2587
2789
|
}
|
|
@@ -2628,12 +2830,14 @@ class RemoveExternalSAMLIdPCertificateResponse extends $tea.Model {
|
|
|
2628
2830
|
static names() {
|
|
2629
2831
|
return {
|
|
2630
2832
|
headers: 'headers',
|
|
2833
|
+
statusCode: 'statusCode',
|
|
2631
2834
|
body: 'body',
|
|
2632
2835
|
};
|
|
2633
2836
|
}
|
|
2634
2837
|
static types() {
|
|
2635
2838
|
return {
|
|
2636
2839
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2840
|
+
statusCode: 'number',
|
|
2637
2841
|
body: RemoveExternalSAMLIdPCertificateResponseBody,
|
|
2638
2842
|
};
|
|
2639
2843
|
}
|
|
@@ -2684,12 +2888,14 @@ class RemovePermissionPolicyFromAccessConfigurationResponse extends $tea.Model {
|
|
|
2684
2888
|
static names() {
|
|
2685
2889
|
return {
|
|
2686
2890
|
headers: 'headers',
|
|
2891
|
+
statusCode: 'statusCode',
|
|
2687
2892
|
body: 'body',
|
|
2688
2893
|
};
|
|
2689
2894
|
}
|
|
2690
2895
|
static types() {
|
|
2691
2896
|
return {
|
|
2692
2897
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2898
|
+
statusCode: 'number',
|
|
2693
2899
|
body: RemovePermissionPolicyFromAccessConfigurationResponseBody,
|
|
2694
2900
|
};
|
|
2695
2901
|
}
|
|
@@ -2738,12 +2944,14 @@ class RemoveUserFromGroupResponse extends $tea.Model {
|
|
|
2738
2944
|
static names() {
|
|
2739
2945
|
return {
|
|
2740
2946
|
headers: 'headers',
|
|
2947
|
+
statusCode: 'statusCode',
|
|
2741
2948
|
body: 'body',
|
|
2742
2949
|
};
|
|
2743
2950
|
}
|
|
2744
2951
|
static types() {
|
|
2745
2952
|
return {
|
|
2746
2953
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2954
|
+
statusCode: 'number',
|
|
2747
2955
|
body: RemoveUserFromGroupResponseBody,
|
|
2748
2956
|
};
|
|
2749
2957
|
}
|
|
@@ -2798,12 +3006,14 @@ class ResetUserPasswordResponse extends $tea.Model {
|
|
|
2798
3006
|
static names() {
|
|
2799
3007
|
return {
|
|
2800
3008
|
headers: 'headers',
|
|
3009
|
+
statusCode: 'statusCode',
|
|
2801
3010
|
body: 'body',
|
|
2802
3011
|
};
|
|
2803
3012
|
}
|
|
2804
3013
|
static types() {
|
|
2805
3014
|
return {
|
|
2806
3015
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3016
|
+
statusCode: 'number',
|
|
2807
3017
|
body: ResetUserPasswordResponseBody,
|
|
2808
3018
|
};
|
|
2809
3019
|
}
|
|
@@ -2862,12 +3072,14 @@ class SetExternalSAMLIdentityProviderResponse extends $tea.Model {
|
|
|
2862
3072
|
static names() {
|
|
2863
3073
|
return {
|
|
2864
3074
|
headers: 'headers',
|
|
3075
|
+
statusCode: 'statusCode',
|
|
2865
3076
|
body: 'body',
|
|
2866
3077
|
};
|
|
2867
3078
|
}
|
|
2868
3079
|
static types() {
|
|
2869
3080
|
return {
|
|
2870
3081
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3082
|
+
statusCode: 'number',
|
|
2871
3083
|
body: SetExternalSAMLIdentityProviderResponseBody,
|
|
2872
3084
|
};
|
|
2873
3085
|
}
|
|
@@ -2914,12 +3126,14 @@ class SetMFAAuthenticationStatusResponse extends $tea.Model {
|
|
|
2914
3126
|
static names() {
|
|
2915
3127
|
return {
|
|
2916
3128
|
headers: 'headers',
|
|
3129
|
+
statusCode: 'statusCode',
|
|
2917
3130
|
body: 'body',
|
|
2918
3131
|
};
|
|
2919
3132
|
}
|
|
2920
3133
|
static types() {
|
|
2921
3134
|
return {
|
|
2922
3135
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3136
|
+
statusCode: 'number',
|
|
2923
3137
|
body: SetMFAAuthenticationStatusResponseBody,
|
|
2924
3138
|
};
|
|
2925
3139
|
}
|
|
@@ -2966,12 +3180,14 @@ class SetSCIMSynchronizationStatusResponse extends $tea.Model {
|
|
|
2966
3180
|
static names() {
|
|
2967
3181
|
return {
|
|
2968
3182
|
headers: 'headers',
|
|
3183
|
+
statusCode: 'statusCode',
|
|
2969
3184
|
body: 'body',
|
|
2970
3185
|
};
|
|
2971
3186
|
}
|
|
2972
3187
|
static types() {
|
|
2973
3188
|
return {
|
|
2974
3189
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3190
|
+
statusCode: 'number',
|
|
2975
3191
|
body: SetSCIMSynchronizationStatusResponseBody,
|
|
2976
3192
|
};
|
|
2977
3193
|
}
|
|
@@ -3026,12 +3242,14 @@ class UpdateAccessConfigurationResponse extends $tea.Model {
|
|
|
3026
3242
|
static names() {
|
|
3027
3243
|
return {
|
|
3028
3244
|
headers: 'headers',
|
|
3245
|
+
statusCode: 'statusCode',
|
|
3029
3246
|
body: 'body',
|
|
3030
3247
|
};
|
|
3031
3248
|
}
|
|
3032
3249
|
static types() {
|
|
3033
3250
|
return {
|
|
3034
3251
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3252
|
+
statusCode: 'number',
|
|
3035
3253
|
body: UpdateAccessConfigurationResponseBody,
|
|
3036
3254
|
};
|
|
3037
3255
|
}
|
|
@@ -3080,12 +3298,14 @@ class UpdateDirectoryResponse extends $tea.Model {
|
|
|
3080
3298
|
static names() {
|
|
3081
3299
|
return {
|
|
3082
3300
|
headers: 'headers',
|
|
3301
|
+
statusCode: 'statusCode',
|
|
3083
3302
|
body: 'body',
|
|
3084
3303
|
};
|
|
3085
3304
|
}
|
|
3086
3305
|
static types() {
|
|
3087
3306
|
return {
|
|
3088
3307
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3308
|
+
statusCode: 'number',
|
|
3089
3309
|
body: UpdateDirectoryResponseBody,
|
|
3090
3310
|
};
|
|
3091
3311
|
}
|
|
@@ -3138,12 +3358,14 @@ class UpdateGroupResponse extends $tea.Model {
|
|
|
3138
3358
|
static names() {
|
|
3139
3359
|
return {
|
|
3140
3360
|
headers: 'headers',
|
|
3361
|
+
statusCode: 'statusCode',
|
|
3141
3362
|
body: 'body',
|
|
3142
3363
|
};
|
|
3143
3364
|
}
|
|
3144
3365
|
static types() {
|
|
3145
3366
|
return {
|
|
3146
3367
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3368
|
+
statusCode: 'number',
|
|
3147
3369
|
body: UpdateGroupResponseBody,
|
|
3148
3370
|
};
|
|
3149
3371
|
}
|
|
@@ -3194,17 +3416,73 @@ class UpdateInlinePolicyForAccessConfigurationResponse extends $tea.Model {
|
|
|
3194
3416
|
static names() {
|
|
3195
3417
|
return {
|
|
3196
3418
|
headers: 'headers',
|
|
3419
|
+
statusCode: 'statusCode',
|
|
3197
3420
|
body: 'body',
|
|
3198
3421
|
};
|
|
3199
3422
|
}
|
|
3200
3423
|
static types() {
|
|
3201
3424
|
return {
|
|
3202
3425
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3426
|
+
statusCode: 'number',
|
|
3203
3427
|
body: UpdateInlinePolicyForAccessConfigurationResponseBody,
|
|
3204
3428
|
};
|
|
3205
3429
|
}
|
|
3206
3430
|
}
|
|
3207
3431
|
exports.UpdateInlinePolicyForAccessConfigurationResponse = UpdateInlinePolicyForAccessConfigurationResponse;
|
|
3432
|
+
class UpdateMFAAuthenticationSettingsRequest extends $tea.Model {
|
|
3433
|
+
constructor(map) {
|
|
3434
|
+
super(map);
|
|
3435
|
+
}
|
|
3436
|
+
static names() {
|
|
3437
|
+
return {
|
|
3438
|
+
directoryId: 'DirectoryId',
|
|
3439
|
+
MFAAuthenticationSettings: 'MFAAuthenticationSettings',
|
|
3440
|
+
};
|
|
3441
|
+
}
|
|
3442
|
+
static types() {
|
|
3443
|
+
return {
|
|
3444
|
+
directoryId: 'string',
|
|
3445
|
+
MFAAuthenticationSettings: 'string',
|
|
3446
|
+
};
|
|
3447
|
+
}
|
|
3448
|
+
}
|
|
3449
|
+
exports.UpdateMFAAuthenticationSettingsRequest = UpdateMFAAuthenticationSettingsRequest;
|
|
3450
|
+
class UpdateMFAAuthenticationSettingsResponseBody extends $tea.Model {
|
|
3451
|
+
constructor(map) {
|
|
3452
|
+
super(map);
|
|
3453
|
+
}
|
|
3454
|
+
static names() {
|
|
3455
|
+
return {
|
|
3456
|
+
requestId: 'RequestId',
|
|
3457
|
+
};
|
|
3458
|
+
}
|
|
3459
|
+
static types() {
|
|
3460
|
+
return {
|
|
3461
|
+
requestId: 'string',
|
|
3462
|
+
};
|
|
3463
|
+
}
|
|
3464
|
+
}
|
|
3465
|
+
exports.UpdateMFAAuthenticationSettingsResponseBody = UpdateMFAAuthenticationSettingsResponseBody;
|
|
3466
|
+
class UpdateMFAAuthenticationSettingsResponse extends $tea.Model {
|
|
3467
|
+
constructor(map) {
|
|
3468
|
+
super(map);
|
|
3469
|
+
}
|
|
3470
|
+
static names() {
|
|
3471
|
+
return {
|
|
3472
|
+
headers: 'headers',
|
|
3473
|
+
statusCode: 'statusCode',
|
|
3474
|
+
body: 'body',
|
|
3475
|
+
};
|
|
3476
|
+
}
|
|
3477
|
+
static types() {
|
|
3478
|
+
return {
|
|
3479
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3480
|
+
statusCode: 'number',
|
|
3481
|
+
body: UpdateMFAAuthenticationSettingsResponseBody,
|
|
3482
|
+
};
|
|
3483
|
+
}
|
|
3484
|
+
}
|
|
3485
|
+
exports.UpdateMFAAuthenticationSettingsResponse = UpdateMFAAuthenticationSettingsResponse;
|
|
3208
3486
|
class UpdateSCIMServerCredentialStatusRequest extends $tea.Model {
|
|
3209
3487
|
constructor(map) {
|
|
3210
3488
|
super(map);
|
|
@@ -3250,12 +3528,14 @@ class UpdateSCIMServerCredentialStatusResponse extends $tea.Model {
|
|
|
3250
3528
|
static names() {
|
|
3251
3529
|
return {
|
|
3252
3530
|
headers: 'headers',
|
|
3531
|
+
statusCode: 'statusCode',
|
|
3253
3532
|
body: 'body',
|
|
3254
3533
|
};
|
|
3255
3534
|
}
|
|
3256
3535
|
static types() {
|
|
3257
3536
|
return {
|
|
3258
3537
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3538
|
+
statusCode: 'number',
|
|
3259
3539
|
body: UpdateSCIMServerCredentialStatusResponseBody,
|
|
3260
3540
|
};
|
|
3261
3541
|
}
|
|
@@ -3314,17 +3594,75 @@ class UpdateUserResponse extends $tea.Model {
|
|
|
3314
3594
|
static names() {
|
|
3315
3595
|
return {
|
|
3316
3596
|
headers: 'headers',
|
|
3597
|
+
statusCode: 'statusCode',
|
|
3317
3598
|
body: 'body',
|
|
3318
3599
|
};
|
|
3319
3600
|
}
|
|
3320
3601
|
static types() {
|
|
3321
3602
|
return {
|
|
3322
3603
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3604
|
+
statusCode: 'number',
|
|
3323
3605
|
body: UpdateUserResponseBody,
|
|
3324
3606
|
};
|
|
3325
3607
|
}
|
|
3326
3608
|
}
|
|
3327
3609
|
exports.UpdateUserResponse = UpdateUserResponse;
|
|
3610
|
+
class UpdateUserMFAAuthenticationSettingsRequest extends $tea.Model {
|
|
3611
|
+
constructor(map) {
|
|
3612
|
+
super(map);
|
|
3613
|
+
}
|
|
3614
|
+
static names() {
|
|
3615
|
+
return {
|
|
3616
|
+
directoryId: 'DirectoryId',
|
|
3617
|
+
userId: 'UserId',
|
|
3618
|
+
userMFAAuthenticationSettings: 'UserMFAAuthenticationSettings',
|
|
3619
|
+
};
|
|
3620
|
+
}
|
|
3621
|
+
static types() {
|
|
3622
|
+
return {
|
|
3623
|
+
directoryId: 'string',
|
|
3624
|
+
userId: 'string',
|
|
3625
|
+
userMFAAuthenticationSettings: 'string',
|
|
3626
|
+
};
|
|
3627
|
+
}
|
|
3628
|
+
}
|
|
3629
|
+
exports.UpdateUserMFAAuthenticationSettingsRequest = UpdateUserMFAAuthenticationSettingsRequest;
|
|
3630
|
+
class UpdateUserMFAAuthenticationSettingsResponseBody extends $tea.Model {
|
|
3631
|
+
constructor(map) {
|
|
3632
|
+
super(map);
|
|
3633
|
+
}
|
|
3634
|
+
static names() {
|
|
3635
|
+
return {
|
|
3636
|
+
requestId: 'RequestId',
|
|
3637
|
+
};
|
|
3638
|
+
}
|
|
3639
|
+
static types() {
|
|
3640
|
+
return {
|
|
3641
|
+
requestId: 'string',
|
|
3642
|
+
};
|
|
3643
|
+
}
|
|
3644
|
+
}
|
|
3645
|
+
exports.UpdateUserMFAAuthenticationSettingsResponseBody = UpdateUserMFAAuthenticationSettingsResponseBody;
|
|
3646
|
+
class UpdateUserMFAAuthenticationSettingsResponse extends $tea.Model {
|
|
3647
|
+
constructor(map) {
|
|
3648
|
+
super(map);
|
|
3649
|
+
}
|
|
3650
|
+
static names() {
|
|
3651
|
+
return {
|
|
3652
|
+
headers: 'headers',
|
|
3653
|
+
statusCode: 'statusCode',
|
|
3654
|
+
body: 'body',
|
|
3655
|
+
};
|
|
3656
|
+
}
|
|
3657
|
+
static types() {
|
|
3658
|
+
return {
|
|
3659
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3660
|
+
statusCode: 'number',
|
|
3661
|
+
body: UpdateUserMFAAuthenticationSettingsResponseBody,
|
|
3662
|
+
};
|
|
3663
|
+
}
|
|
3664
|
+
}
|
|
3665
|
+
exports.UpdateUserMFAAuthenticationSettingsResponse = UpdateUserMFAAuthenticationSettingsResponse;
|
|
3328
3666
|
class UpdateUserStatusRequest extends $tea.Model {
|
|
3329
3667
|
constructor(map) {
|
|
3330
3668
|
super(map);
|
|
@@ -3368,12 +3706,14 @@ class UpdateUserStatusResponse extends $tea.Model {
|
|
|
3368
3706
|
static names() {
|
|
3369
3707
|
return {
|
|
3370
3708
|
headers: 'headers',
|
|
3709
|
+
statusCode: 'statusCode',
|
|
3371
3710
|
body: 'body',
|
|
3372
3711
|
};
|
|
3373
3712
|
}
|
|
3374
3713
|
static types() {
|
|
3375
3714
|
return {
|
|
3376
3715
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3716
|
+
statusCode: 'number',
|
|
3377
3717
|
body: UpdateUserStatusResponseBody,
|
|
3378
3718
|
};
|
|
3379
3719
|
}
|
|
@@ -4572,11 +4912,14 @@ class Client extends openapi_client_1.default {
|
|
|
4572
4912
|
async addExternalSAMLIdPCertificateWithOptions(request, runtime) {
|
|
4573
4913
|
tea_util_1.default.validateModel(request);
|
|
4574
4914
|
let query = {};
|
|
4575
|
-
|
|
4576
|
-
|
|
4915
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
4916
|
+
query["DirectoryId"] = request.directoryId;
|
|
4917
|
+
}
|
|
4918
|
+
if (!tea_util_1.default.isUnset(request.x509Certificate)) {
|
|
4919
|
+
query["X509Certificate"] = request.x509Certificate;
|
|
4920
|
+
}
|
|
4577
4921
|
let req = new $OpenApi.OpenApiRequest({
|
|
4578
4922
|
query: openapi_util_1.default.query(query),
|
|
4579
|
-
body: tea_util_1.default.toMap(request),
|
|
4580
4923
|
});
|
|
4581
4924
|
let params = new $OpenApi.Params({
|
|
4582
4925
|
action: "AddExternalSAMLIdPCertificate",
|
|
@@ -4586,7 +4929,7 @@ class Client extends openapi_client_1.default {
|
|
|
4586
4929
|
method: "POST",
|
|
4587
4930
|
authType: "AK",
|
|
4588
4931
|
style: "RPC",
|
|
4589
|
-
reqBodyType: "
|
|
4932
|
+
reqBodyType: "formData",
|
|
4590
4933
|
bodyType: "json",
|
|
4591
4934
|
});
|
|
4592
4935
|
return $tea.cast(await this.callApi(params, req, runtime), new AddExternalSAMLIdPCertificateResponse({}));
|
|
@@ -4598,14 +4941,23 @@ class Client extends openapi_client_1.default {
|
|
|
4598
4941
|
async addPermissionPolicyToAccessConfigurationWithOptions(request, runtime) {
|
|
4599
4942
|
tea_util_1.default.validateModel(request);
|
|
4600
4943
|
let query = {};
|
|
4601
|
-
|
|
4602
|
-
|
|
4603
|
-
|
|
4604
|
-
|
|
4605
|
-
|
|
4944
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
4945
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
4946
|
+
}
|
|
4947
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
4948
|
+
query["DirectoryId"] = request.directoryId;
|
|
4949
|
+
}
|
|
4950
|
+
if (!tea_util_1.default.isUnset(request.inlinePolicyDocument)) {
|
|
4951
|
+
query["InlinePolicyDocument"] = request.inlinePolicyDocument;
|
|
4952
|
+
}
|
|
4953
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyName)) {
|
|
4954
|
+
query["PermissionPolicyName"] = request.permissionPolicyName;
|
|
4955
|
+
}
|
|
4956
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyType)) {
|
|
4957
|
+
query["PermissionPolicyType"] = request.permissionPolicyType;
|
|
4958
|
+
}
|
|
4606
4959
|
let req = new $OpenApi.OpenApiRequest({
|
|
4607
4960
|
query: openapi_util_1.default.query(query),
|
|
4608
|
-
body: tea_util_1.default.toMap(request),
|
|
4609
4961
|
});
|
|
4610
4962
|
let params = new $OpenApi.Params({
|
|
4611
4963
|
action: "AddPermissionPolicyToAccessConfiguration",
|
|
@@ -4615,7 +4967,7 @@ class Client extends openapi_client_1.default {
|
|
|
4615
4967
|
method: "POST",
|
|
4616
4968
|
authType: "AK",
|
|
4617
4969
|
style: "RPC",
|
|
4618
|
-
reqBodyType: "
|
|
4970
|
+
reqBodyType: "formData",
|
|
4619
4971
|
bodyType: "json",
|
|
4620
4972
|
});
|
|
4621
4973
|
return $tea.cast(await this.callApi(params, req, runtime), new AddPermissionPolicyToAccessConfigurationResponse({}));
|
|
@@ -4627,12 +4979,17 @@ class Client extends openapi_client_1.default {
|
|
|
4627
4979
|
async addUserToGroupWithOptions(request, runtime) {
|
|
4628
4980
|
tea_util_1.default.validateModel(request);
|
|
4629
4981
|
let query = {};
|
|
4630
|
-
|
|
4631
|
-
|
|
4632
|
-
|
|
4982
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
4983
|
+
query["DirectoryId"] = request.directoryId;
|
|
4984
|
+
}
|
|
4985
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
4986
|
+
query["GroupId"] = request.groupId;
|
|
4987
|
+
}
|
|
4988
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
4989
|
+
query["UserId"] = request.userId;
|
|
4990
|
+
}
|
|
4633
4991
|
let req = new $OpenApi.OpenApiRequest({
|
|
4634
4992
|
query: openapi_util_1.default.query(query),
|
|
4635
|
-
body: tea_util_1.default.toMap(request),
|
|
4636
4993
|
});
|
|
4637
4994
|
let params = new $OpenApi.Params({
|
|
4638
4995
|
action: "AddUserToGroup",
|
|
@@ -4642,7 +4999,7 @@ class Client extends openapi_client_1.default {
|
|
|
4642
4999
|
method: "POST",
|
|
4643
5000
|
authType: "AK",
|
|
4644
5001
|
style: "RPC",
|
|
4645
|
-
reqBodyType: "
|
|
5002
|
+
reqBodyType: "formData",
|
|
4646
5003
|
bodyType: "json",
|
|
4647
5004
|
});
|
|
4648
5005
|
return $tea.cast(await this.callApi(params, req, runtime), new AddUserToGroupResponse({}));
|
|
@@ -4654,10 +5011,11 @@ class Client extends openapi_client_1.default {
|
|
|
4654
5011
|
async clearExternalSAMLIdentityProviderWithOptions(request, runtime) {
|
|
4655
5012
|
tea_util_1.default.validateModel(request);
|
|
4656
5013
|
let query = {};
|
|
4657
|
-
|
|
5014
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5015
|
+
query["DirectoryId"] = request.directoryId;
|
|
5016
|
+
}
|
|
4658
5017
|
let req = new $OpenApi.OpenApiRequest({
|
|
4659
5018
|
query: openapi_util_1.default.query(query),
|
|
4660
|
-
body: tea_util_1.default.toMap(request),
|
|
4661
5019
|
});
|
|
4662
5020
|
let params = new $OpenApi.Params({
|
|
4663
5021
|
action: "ClearExternalSAMLIdentityProvider",
|
|
@@ -4667,7 +5025,7 @@ class Client extends openapi_client_1.default {
|
|
|
4667
5025
|
method: "POST",
|
|
4668
5026
|
authType: "AK",
|
|
4669
5027
|
style: "RPC",
|
|
4670
|
-
reqBodyType: "
|
|
5028
|
+
reqBodyType: "formData",
|
|
4671
5029
|
bodyType: "json",
|
|
4672
5030
|
});
|
|
4673
5031
|
return $tea.cast(await this.callApi(params, req, runtime), new ClearExternalSAMLIdentityProviderResponse({}));
|
|
@@ -4679,15 +5037,26 @@ class Client extends openapi_client_1.default {
|
|
|
4679
5037
|
async createAccessAssignmentWithOptions(request, runtime) {
|
|
4680
5038
|
tea_util_1.default.validateModel(request);
|
|
4681
5039
|
let query = {};
|
|
4682
|
-
|
|
4683
|
-
|
|
4684
|
-
|
|
4685
|
-
|
|
4686
|
-
|
|
4687
|
-
|
|
5040
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5041
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5042
|
+
}
|
|
5043
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5044
|
+
query["DirectoryId"] = request.directoryId;
|
|
5045
|
+
}
|
|
5046
|
+
if (!tea_util_1.default.isUnset(request.principalId)) {
|
|
5047
|
+
query["PrincipalId"] = request.principalId;
|
|
5048
|
+
}
|
|
5049
|
+
if (!tea_util_1.default.isUnset(request.principalType)) {
|
|
5050
|
+
query["PrincipalType"] = request.principalType;
|
|
5051
|
+
}
|
|
5052
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5053
|
+
query["TargetId"] = request.targetId;
|
|
5054
|
+
}
|
|
5055
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5056
|
+
query["TargetType"] = request.targetType;
|
|
5057
|
+
}
|
|
4688
5058
|
let req = new $OpenApi.OpenApiRequest({
|
|
4689
5059
|
query: openapi_util_1.default.query(query),
|
|
4690
|
-
body: tea_util_1.default.toMap(request),
|
|
4691
5060
|
});
|
|
4692
5061
|
let params = new $OpenApi.Params({
|
|
4693
5062
|
action: "CreateAccessAssignment",
|
|
@@ -4697,7 +5066,7 @@ class Client extends openapi_client_1.default {
|
|
|
4697
5066
|
method: "POST",
|
|
4698
5067
|
authType: "AK",
|
|
4699
5068
|
style: "RPC",
|
|
4700
|
-
reqBodyType: "
|
|
5069
|
+
reqBodyType: "formData",
|
|
4701
5070
|
bodyType: "json",
|
|
4702
5071
|
});
|
|
4703
5072
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateAccessAssignmentResponse({}));
|
|
@@ -4709,14 +5078,23 @@ class Client extends openapi_client_1.default {
|
|
|
4709
5078
|
async createAccessConfigurationWithOptions(request, runtime) {
|
|
4710
5079
|
tea_util_1.default.validateModel(request);
|
|
4711
5080
|
let query = {};
|
|
4712
|
-
|
|
4713
|
-
|
|
4714
|
-
|
|
4715
|
-
|
|
4716
|
-
|
|
5081
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationName)) {
|
|
5082
|
+
query["AccessConfigurationName"] = request.accessConfigurationName;
|
|
5083
|
+
}
|
|
5084
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
5085
|
+
query["Description"] = request.description;
|
|
5086
|
+
}
|
|
5087
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5088
|
+
query["DirectoryId"] = request.directoryId;
|
|
5089
|
+
}
|
|
5090
|
+
if (!tea_util_1.default.isUnset(request.relayState)) {
|
|
5091
|
+
query["RelayState"] = request.relayState;
|
|
5092
|
+
}
|
|
5093
|
+
if (!tea_util_1.default.isUnset(request.sessionDuration)) {
|
|
5094
|
+
query["SessionDuration"] = request.sessionDuration;
|
|
5095
|
+
}
|
|
4717
5096
|
let req = new $OpenApi.OpenApiRequest({
|
|
4718
5097
|
query: openapi_util_1.default.query(query),
|
|
4719
|
-
body: tea_util_1.default.toMap(request),
|
|
4720
5098
|
});
|
|
4721
5099
|
let params = new $OpenApi.Params({
|
|
4722
5100
|
action: "CreateAccessConfiguration",
|
|
@@ -4726,7 +5104,7 @@ class Client extends openapi_client_1.default {
|
|
|
4726
5104
|
method: "POST",
|
|
4727
5105
|
authType: "AK",
|
|
4728
5106
|
style: "RPC",
|
|
4729
|
-
reqBodyType: "
|
|
5107
|
+
reqBodyType: "formData",
|
|
4730
5108
|
bodyType: "json",
|
|
4731
5109
|
});
|
|
4732
5110
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateAccessConfigurationResponse({}));
|
|
@@ -4738,10 +5116,11 @@ class Client extends openapi_client_1.default {
|
|
|
4738
5116
|
async createDirectoryWithOptions(request, runtime) {
|
|
4739
5117
|
tea_util_1.default.validateModel(request);
|
|
4740
5118
|
let query = {};
|
|
4741
|
-
|
|
5119
|
+
if (!tea_util_1.default.isUnset(request.directoryName)) {
|
|
5120
|
+
query["DirectoryName"] = request.directoryName;
|
|
5121
|
+
}
|
|
4742
5122
|
let req = new $OpenApi.OpenApiRequest({
|
|
4743
5123
|
query: openapi_util_1.default.query(query),
|
|
4744
|
-
body: tea_util_1.default.toMap(request),
|
|
4745
5124
|
});
|
|
4746
5125
|
let params = new $OpenApi.Params({
|
|
4747
5126
|
action: "CreateDirectory",
|
|
@@ -4751,7 +5130,7 @@ class Client extends openapi_client_1.default {
|
|
|
4751
5130
|
method: "POST",
|
|
4752
5131
|
authType: "AK",
|
|
4753
5132
|
style: "RPC",
|
|
4754
|
-
reqBodyType: "
|
|
5133
|
+
reqBodyType: "formData",
|
|
4755
5134
|
bodyType: "json",
|
|
4756
5135
|
});
|
|
4757
5136
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateDirectoryResponse({}));
|
|
@@ -4763,12 +5142,17 @@ class Client extends openapi_client_1.default {
|
|
|
4763
5142
|
async createGroupWithOptions(request, runtime) {
|
|
4764
5143
|
tea_util_1.default.validateModel(request);
|
|
4765
5144
|
let query = {};
|
|
4766
|
-
|
|
4767
|
-
|
|
4768
|
-
|
|
5145
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
5146
|
+
query["Description"] = request.description;
|
|
5147
|
+
}
|
|
5148
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5149
|
+
query["DirectoryId"] = request.directoryId;
|
|
5150
|
+
}
|
|
5151
|
+
if (!tea_util_1.default.isUnset(request.groupName)) {
|
|
5152
|
+
query["GroupName"] = request.groupName;
|
|
5153
|
+
}
|
|
4769
5154
|
let req = new $OpenApi.OpenApiRequest({
|
|
4770
5155
|
query: openapi_util_1.default.query(query),
|
|
4771
|
-
body: tea_util_1.default.toMap(request),
|
|
4772
5156
|
});
|
|
4773
5157
|
let params = new $OpenApi.Params({
|
|
4774
5158
|
action: "CreateGroup",
|
|
@@ -4778,7 +5162,7 @@ class Client extends openapi_client_1.default {
|
|
|
4778
5162
|
method: "POST",
|
|
4779
5163
|
authType: "AK",
|
|
4780
5164
|
style: "RPC",
|
|
4781
|
-
reqBodyType: "
|
|
5165
|
+
reqBodyType: "formData",
|
|
4782
5166
|
bodyType: "json",
|
|
4783
5167
|
});
|
|
4784
5168
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateGroupResponse({}));
|
|
@@ -4790,10 +5174,11 @@ class Client extends openapi_client_1.default {
|
|
|
4790
5174
|
async createSCIMServerCredentialWithOptions(request, runtime) {
|
|
4791
5175
|
tea_util_1.default.validateModel(request);
|
|
4792
5176
|
let query = {};
|
|
4793
|
-
|
|
5177
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5178
|
+
query["DirectoryId"] = request.directoryId;
|
|
5179
|
+
}
|
|
4794
5180
|
let req = new $OpenApi.OpenApiRequest({
|
|
4795
5181
|
query: openapi_util_1.default.query(query),
|
|
4796
|
-
body: tea_util_1.default.toMap(request),
|
|
4797
5182
|
});
|
|
4798
5183
|
let params = new $OpenApi.Params({
|
|
4799
5184
|
action: "CreateSCIMServerCredential",
|
|
@@ -4803,7 +5188,7 @@ class Client extends openapi_client_1.default {
|
|
|
4803
5188
|
method: "POST",
|
|
4804
5189
|
authType: "AK",
|
|
4805
5190
|
style: "RPC",
|
|
4806
|
-
reqBodyType: "
|
|
5191
|
+
reqBodyType: "formData",
|
|
4807
5192
|
bodyType: "json",
|
|
4808
5193
|
});
|
|
4809
5194
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateSCIMServerCredentialResponse({}));
|
|
@@ -4815,17 +5200,32 @@ class Client extends openapi_client_1.default {
|
|
|
4815
5200
|
async createUserWithOptions(request, runtime) {
|
|
4816
5201
|
tea_util_1.default.validateModel(request);
|
|
4817
5202
|
let query = {};
|
|
4818
|
-
|
|
4819
|
-
|
|
4820
|
-
|
|
4821
|
-
|
|
4822
|
-
|
|
4823
|
-
|
|
4824
|
-
|
|
4825
|
-
|
|
5203
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
5204
|
+
query["Description"] = request.description;
|
|
5205
|
+
}
|
|
5206
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5207
|
+
query["DirectoryId"] = request.directoryId;
|
|
5208
|
+
}
|
|
5209
|
+
if (!tea_util_1.default.isUnset(request.displayName)) {
|
|
5210
|
+
query["DisplayName"] = request.displayName;
|
|
5211
|
+
}
|
|
5212
|
+
if (!tea_util_1.default.isUnset(request.email)) {
|
|
5213
|
+
query["Email"] = request.email;
|
|
5214
|
+
}
|
|
5215
|
+
if (!tea_util_1.default.isUnset(request.firstName)) {
|
|
5216
|
+
query["FirstName"] = request.firstName;
|
|
5217
|
+
}
|
|
5218
|
+
if (!tea_util_1.default.isUnset(request.lastName)) {
|
|
5219
|
+
query["LastName"] = request.lastName;
|
|
5220
|
+
}
|
|
5221
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
5222
|
+
query["Status"] = request.status;
|
|
5223
|
+
}
|
|
5224
|
+
if (!tea_util_1.default.isUnset(request.userName)) {
|
|
5225
|
+
query["UserName"] = request.userName;
|
|
5226
|
+
}
|
|
4826
5227
|
let req = new $OpenApi.OpenApiRequest({
|
|
4827
5228
|
query: openapi_util_1.default.query(query),
|
|
4828
|
-
body: tea_util_1.default.toMap(request),
|
|
4829
5229
|
});
|
|
4830
5230
|
let params = new $OpenApi.Params({
|
|
4831
5231
|
action: "CreateUser",
|
|
@@ -4835,7 +5235,7 @@ class Client extends openapi_client_1.default {
|
|
|
4835
5235
|
method: "POST",
|
|
4836
5236
|
authType: "AK",
|
|
4837
5237
|
style: "RPC",
|
|
4838
|
-
reqBodyType: "
|
|
5238
|
+
reqBodyType: "formData",
|
|
4839
5239
|
bodyType: "json",
|
|
4840
5240
|
});
|
|
4841
5241
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateUserResponse({}));
|
|
@@ -4847,16 +5247,29 @@ class Client extends openapi_client_1.default {
|
|
|
4847
5247
|
async deleteAccessAssignmentWithOptions(request, runtime) {
|
|
4848
5248
|
tea_util_1.default.validateModel(request);
|
|
4849
5249
|
let query = {};
|
|
4850
|
-
|
|
4851
|
-
|
|
4852
|
-
|
|
4853
|
-
|
|
4854
|
-
|
|
4855
|
-
|
|
4856
|
-
|
|
5250
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5251
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5252
|
+
}
|
|
5253
|
+
if (!tea_util_1.default.isUnset(request.deprovisionStrategy)) {
|
|
5254
|
+
query["DeprovisionStrategy"] = request.deprovisionStrategy;
|
|
5255
|
+
}
|
|
5256
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5257
|
+
query["DirectoryId"] = request.directoryId;
|
|
5258
|
+
}
|
|
5259
|
+
if (!tea_util_1.default.isUnset(request.principalId)) {
|
|
5260
|
+
query["PrincipalId"] = request.principalId;
|
|
5261
|
+
}
|
|
5262
|
+
if (!tea_util_1.default.isUnset(request.principalType)) {
|
|
5263
|
+
query["PrincipalType"] = request.principalType;
|
|
5264
|
+
}
|
|
5265
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5266
|
+
query["TargetId"] = request.targetId;
|
|
5267
|
+
}
|
|
5268
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5269
|
+
query["TargetType"] = request.targetType;
|
|
5270
|
+
}
|
|
4857
5271
|
let req = new $OpenApi.OpenApiRequest({
|
|
4858
5272
|
query: openapi_util_1.default.query(query),
|
|
4859
|
-
body: tea_util_1.default.toMap(request),
|
|
4860
5273
|
});
|
|
4861
5274
|
let params = new $OpenApi.Params({
|
|
4862
5275
|
action: "DeleteAccessAssignment",
|
|
@@ -4866,7 +5279,7 @@ class Client extends openapi_client_1.default {
|
|
|
4866
5279
|
method: "POST",
|
|
4867
5280
|
authType: "AK",
|
|
4868
5281
|
style: "RPC",
|
|
4869
|
-
reqBodyType: "
|
|
5282
|
+
reqBodyType: "formData",
|
|
4870
5283
|
bodyType: "json",
|
|
4871
5284
|
});
|
|
4872
5285
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteAccessAssignmentResponse({}));
|
|
@@ -4878,12 +5291,17 @@ class Client extends openapi_client_1.default {
|
|
|
4878
5291
|
async deleteAccessConfigurationWithOptions(request, runtime) {
|
|
4879
5292
|
tea_util_1.default.validateModel(request);
|
|
4880
5293
|
let query = {};
|
|
4881
|
-
|
|
4882
|
-
|
|
4883
|
-
|
|
5294
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5295
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5296
|
+
}
|
|
5297
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5298
|
+
query["DirectoryId"] = request.directoryId;
|
|
5299
|
+
}
|
|
5300
|
+
if (!tea_util_1.default.isUnset(request.forceRemovePermissionPolicies)) {
|
|
5301
|
+
query["ForceRemovePermissionPolicies"] = request.forceRemovePermissionPolicies;
|
|
5302
|
+
}
|
|
4884
5303
|
let req = new $OpenApi.OpenApiRequest({
|
|
4885
5304
|
query: openapi_util_1.default.query(query),
|
|
4886
|
-
body: tea_util_1.default.toMap(request),
|
|
4887
5305
|
});
|
|
4888
5306
|
let params = new $OpenApi.Params({
|
|
4889
5307
|
action: "DeleteAccessConfiguration",
|
|
@@ -4893,7 +5311,7 @@ class Client extends openapi_client_1.default {
|
|
|
4893
5311
|
method: "POST",
|
|
4894
5312
|
authType: "AK",
|
|
4895
5313
|
style: "RPC",
|
|
4896
|
-
reqBodyType: "
|
|
5314
|
+
reqBodyType: "formData",
|
|
4897
5315
|
bodyType: "json",
|
|
4898
5316
|
});
|
|
4899
5317
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteAccessConfigurationResponse({}));
|
|
@@ -4905,10 +5323,11 @@ class Client extends openapi_client_1.default {
|
|
|
4905
5323
|
async deleteDirectoryWithOptions(request, runtime) {
|
|
4906
5324
|
tea_util_1.default.validateModel(request);
|
|
4907
5325
|
let query = {};
|
|
4908
|
-
|
|
5326
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5327
|
+
query["DirectoryId"] = request.directoryId;
|
|
5328
|
+
}
|
|
4909
5329
|
let req = new $OpenApi.OpenApiRequest({
|
|
4910
5330
|
query: openapi_util_1.default.query(query),
|
|
4911
|
-
body: tea_util_1.default.toMap(request),
|
|
4912
5331
|
});
|
|
4913
5332
|
let params = new $OpenApi.Params({
|
|
4914
5333
|
action: "DeleteDirectory",
|
|
@@ -4918,7 +5337,7 @@ class Client extends openapi_client_1.default {
|
|
|
4918
5337
|
method: "POST",
|
|
4919
5338
|
authType: "AK",
|
|
4920
5339
|
style: "RPC",
|
|
4921
|
-
reqBodyType: "
|
|
5340
|
+
reqBodyType: "formData",
|
|
4922
5341
|
bodyType: "json",
|
|
4923
5342
|
});
|
|
4924
5343
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteDirectoryResponse({}));
|
|
@@ -4930,11 +5349,14 @@ class Client extends openapi_client_1.default {
|
|
|
4930
5349
|
async deleteGroupWithOptions(request, runtime) {
|
|
4931
5350
|
tea_util_1.default.validateModel(request);
|
|
4932
5351
|
let query = {};
|
|
4933
|
-
|
|
4934
|
-
|
|
5352
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5353
|
+
query["DirectoryId"] = request.directoryId;
|
|
5354
|
+
}
|
|
5355
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
5356
|
+
query["GroupId"] = request.groupId;
|
|
5357
|
+
}
|
|
4935
5358
|
let req = new $OpenApi.OpenApiRequest({
|
|
4936
5359
|
query: openapi_util_1.default.query(query),
|
|
4937
|
-
body: tea_util_1.default.toMap(request),
|
|
4938
5360
|
});
|
|
4939
5361
|
let params = new $OpenApi.Params({
|
|
4940
5362
|
action: "DeleteGroup",
|
|
@@ -4944,7 +5366,7 @@ class Client extends openapi_client_1.default {
|
|
|
4944
5366
|
method: "POST",
|
|
4945
5367
|
authType: "AK",
|
|
4946
5368
|
style: "RPC",
|
|
4947
|
-
reqBodyType: "
|
|
5369
|
+
reqBodyType: "formData",
|
|
4948
5370
|
bodyType: "json",
|
|
4949
5371
|
});
|
|
4950
5372
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteGroupResponse({}));
|
|
@@ -4956,12 +5378,17 @@ class Client extends openapi_client_1.default {
|
|
|
4956
5378
|
async deleteMFADeviceForUserWithOptions(request, runtime) {
|
|
4957
5379
|
tea_util_1.default.validateModel(request);
|
|
4958
5380
|
let query = {};
|
|
4959
|
-
|
|
4960
|
-
|
|
4961
|
-
|
|
5381
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5382
|
+
query["DirectoryId"] = request.directoryId;
|
|
5383
|
+
}
|
|
5384
|
+
if (!tea_util_1.default.isUnset(request.MFADeviceId)) {
|
|
5385
|
+
query["MFADeviceId"] = request.MFADeviceId;
|
|
5386
|
+
}
|
|
5387
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
5388
|
+
query["UserId"] = request.userId;
|
|
5389
|
+
}
|
|
4962
5390
|
let req = new $OpenApi.OpenApiRequest({
|
|
4963
5391
|
query: openapi_util_1.default.query(query),
|
|
4964
|
-
body: tea_util_1.default.toMap(request),
|
|
4965
5392
|
});
|
|
4966
5393
|
let params = new $OpenApi.Params({
|
|
4967
5394
|
action: "DeleteMFADeviceForUser",
|
|
@@ -4971,7 +5398,7 @@ class Client extends openapi_client_1.default {
|
|
|
4971
5398
|
method: "POST",
|
|
4972
5399
|
authType: "AK",
|
|
4973
5400
|
style: "RPC",
|
|
4974
|
-
reqBodyType: "
|
|
5401
|
+
reqBodyType: "formData",
|
|
4975
5402
|
bodyType: "json",
|
|
4976
5403
|
});
|
|
4977
5404
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteMFADeviceForUserResponse({}));
|
|
@@ -4983,11 +5410,14 @@ class Client extends openapi_client_1.default {
|
|
|
4983
5410
|
async deleteSCIMServerCredentialWithOptions(request, runtime) {
|
|
4984
5411
|
tea_util_1.default.validateModel(request);
|
|
4985
5412
|
let query = {};
|
|
4986
|
-
|
|
4987
|
-
|
|
5413
|
+
if (!tea_util_1.default.isUnset(request.credentialId)) {
|
|
5414
|
+
query["CredentialId"] = request.credentialId;
|
|
5415
|
+
}
|
|
5416
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5417
|
+
query["DirectoryId"] = request.directoryId;
|
|
5418
|
+
}
|
|
4988
5419
|
let req = new $OpenApi.OpenApiRequest({
|
|
4989
5420
|
query: openapi_util_1.default.query(query),
|
|
4990
|
-
body: tea_util_1.default.toMap(request),
|
|
4991
5421
|
});
|
|
4992
5422
|
let params = new $OpenApi.Params({
|
|
4993
5423
|
action: "DeleteSCIMServerCredential",
|
|
@@ -4997,7 +5427,7 @@ class Client extends openapi_client_1.default {
|
|
|
4997
5427
|
method: "POST",
|
|
4998
5428
|
authType: "AK",
|
|
4999
5429
|
style: "RPC",
|
|
5000
|
-
reqBodyType: "
|
|
5430
|
+
reqBodyType: "formData",
|
|
5001
5431
|
bodyType: "json",
|
|
5002
5432
|
});
|
|
5003
5433
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteSCIMServerCredentialResponse({}));
|
|
@@ -5009,11 +5439,14 @@ class Client extends openapi_client_1.default {
|
|
|
5009
5439
|
async deleteUserWithOptions(request, runtime) {
|
|
5010
5440
|
tea_util_1.default.validateModel(request);
|
|
5011
5441
|
let query = {};
|
|
5012
|
-
|
|
5013
|
-
|
|
5442
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5443
|
+
query["DirectoryId"] = request.directoryId;
|
|
5444
|
+
}
|
|
5445
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
5446
|
+
query["UserId"] = request.userId;
|
|
5447
|
+
}
|
|
5014
5448
|
let req = new $OpenApi.OpenApiRequest({
|
|
5015
5449
|
query: openapi_util_1.default.query(query),
|
|
5016
|
-
body: tea_util_1.default.toMap(request),
|
|
5017
5450
|
});
|
|
5018
5451
|
let params = new $OpenApi.Params({
|
|
5019
5452
|
action: "DeleteUser",
|
|
@@ -5023,7 +5456,7 @@ class Client extends openapi_client_1.default {
|
|
|
5023
5456
|
method: "POST",
|
|
5024
5457
|
authType: "AK",
|
|
5025
5458
|
style: "RPC",
|
|
5026
|
-
reqBodyType: "
|
|
5459
|
+
reqBodyType: "formData",
|
|
5027
5460
|
bodyType: "json",
|
|
5028
5461
|
});
|
|
5029
5462
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteUserResponse({}));
|
|
@@ -5035,13 +5468,20 @@ class Client extends openapi_client_1.default {
|
|
|
5035
5468
|
async deprovisionAccessConfigurationWithOptions(request, runtime) {
|
|
5036
5469
|
tea_util_1.default.validateModel(request);
|
|
5037
5470
|
let query = {};
|
|
5038
|
-
|
|
5039
|
-
|
|
5040
|
-
|
|
5041
|
-
|
|
5471
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5472
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5473
|
+
}
|
|
5474
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5475
|
+
query["DirectoryId"] = request.directoryId;
|
|
5476
|
+
}
|
|
5477
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5478
|
+
query["TargetId"] = request.targetId;
|
|
5479
|
+
}
|
|
5480
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5481
|
+
query["TargetType"] = request.targetType;
|
|
5482
|
+
}
|
|
5042
5483
|
let req = new $OpenApi.OpenApiRequest({
|
|
5043
5484
|
query: openapi_util_1.default.query(query),
|
|
5044
|
-
body: tea_util_1.default.toMap(request),
|
|
5045
5485
|
});
|
|
5046
5486
|
let params = new $OpenApi.Params({
|
|
5047
5487
|
action: "DeprovisionAccessConfiguration",
|
|
@@ -5051,7 +5491,7 @@ class Client extends openapi_client_1.default {
|
|
|
5051
5491
|
method: "POST",
|
|
5052
5492
|
authType: "AK",
|
|
5053
5493
|
style: "RPC",
|
|
5054
|
-
reqBodyType: "
|
|
5494
|
+
reqBodyType: "formData",
|
|
5055
5495
|
bodyType: "json",
|
|
5056
5496
|
});
|
|
5057
5497
|
return $tea.cast(await this.callApi(params, req, runtime), new DeprovisionAccessConfigurationResponse({}));
|
|
@@ -5070,7 +5510,7 @@ class Client extends openapi_client_1.default {
|
|
|
5070
5510
|
method: "POST",
|
|
5071
5511
|
authType: "AK",
|
|
5072
5512
|
style: "RPC",
|
|
5073
|
-
reqBodyType: "
|
|
5513
|
+
reqBodyType: "formData",
|
|
5074
5514
|
bodyType: "json",
|
|
5075
5515
|
});
|
|
5076
5516
|
return $tea.cast(await this.callApi(params, req, runtime), new DisableServiceResponse({}));
|
|
@@ -5089,7 +5529,7 @@ class Client extends openapi_client_1.default {
|
|
|
5089
5529
|
method: "POST",
|
|
5090
5530
|
authType: "AK",
|
|
5091
5531
|
style: "RPC",
|
|
5092
|
-
reqBodyType: "
|
|
5532
|
+
reqBodyType: "formData",
|
|
5093
5533
|
bodyType: "json",
|
|
5094
5534
|
});
|
|
5095
5535
|
return $tea.cast(await this.callApi(params, req, runtime), new EnableServiceResponse({}));
|
|
@@ -5101,11 +5541,14 @@ class Client extends openapi_client_1.default {
|
|
|
5101
5541
|
async getAccessConfigurationWithOptions(request, runtime) {
|
|
5102
5542
|
tea_util_1.default.validateModel(request);
|
|
5103
5543
|
let query = {};
|
|
5104
|
-
|
|
5105
|
-
|
|
5544
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5545
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5546
|
+
}
|
|
5547
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5548
|
+
query["DirectoryId"] = request.directoryId;
|
|
5549
|
+
}
|
|
5106
5550
|
let req = new $OpenApi.OpenApiRequest({
|
|
5107
5551
|
query: openapi_util_1.default.query(query),
|
|
5108
|
-
body: tea_util_1.default.toMap(request),
|
|
5109
5552
|
});
|
|
5110
5553
|
let params = new $OpenApi.Params({
|
|
5111
5554
|
action: "GetAccessConfiguration",
|
|
@@ -5115,7 +5558,7 @@ class Client extends openapi_client_1.default {
|
|
|
5115
5558
|
method: "POST",
|
|
5116
5559
|
authType: "AK",
|
|
5117
5560
|
style: "RPC",
|
|
5118
|
-
reqBodyType: "
|
|
5561
|
+
reqBodyType: "formData",
|
|
5119
5562
|
bodyType: "json",
|
|
5120
5563
|
});
|
|
5121
5564
|
return $tea.cast(await this.callApi(params, req, runtime), new GetAccessConfigurationResponse({}));
|
|
@@ -5127,10 +5570,11 @@ class Client extends openapi_client_1.default {
|
|
|
5127
5570
|
async getDirectoryWithOptions(request, runtime) {
|
|
5128
5571
|
tea_util_1.default.validateModel(request);
|
|
5129
5572
|
let query = {};
|
|
5130
|
-
|
|
5573
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5574
|
+
query["DirectoryId"] = request.directoryId;
|
|
5575
|
+
}
|
|
5131
5576
|
let req = new $OpenApi.OpenApiRequest({
|
|
5132
5577
|
query: openapi_util_1.default.query(query),
|
|
5133
|
-
body: tea_util_1.default.toMap(request),
|
|
5134
5578
|
});
|
|
5135
5579
|
let params = new $OpenApi.Params({
|
|
5136
5580
|
action: "GetDirectory",
|
|
@@ -5140,7 +5584,7 @@ class Client extends openapi_client_1.default {
|
|
|
5140
5584
|
method: "POST",
|
|
5141
5585
|
authType: "AK",
|
|
5142
5586
|
style: "RPC",
|
|
5143
|
-
reqBodyType: "
|
|
5587
|
+
reqBodyType: "formData",
|
|
5144
5588
|
bodyType: "json",
|
|
5145
5589
|
});
|
|
5146
5590
|
return $tea.cast(await this.callApi(params, req, runtime), new GetDirectoryResponse({}));
|
|
@@ -5152,10 +5596,11 @@ class Client extends openapi_client_1.default {
|
|
|
5152
5596
|
async getDirectorySAMLServiceProviderInfoWithOptions(request, runtime) {
|
|
5153
5597
|
tea_util_1.default.validateModel(request);
|
|
5154
5598
|
let query = {};
|
|
5155
|
-
|
|
5599
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5600
|
+
query["DirectoryId"] = request.directoryId;
|
|
5601
|
+
}
|
|
5156
5602
|
let req = new $OpenApi.OpenApiRequest({
|
|
5157
5603
|
query: openapi_util_1.default.query(query),
|
|
5158
|
-
body: tea_util_1.default.toMap(request),
|
|
5159
5604
|
});
|
|
5160
5605
|
let params = new $OpenApi.Params({
|
|
5161
5606
|
action: "GetDirectorySAMLServiceProviderInfo",
|
|
@@ -5165,7 +5610,7 @@ class Client extends openapi_client_1.default {
|
|
|
5165
5610
|
method: "POST",
|
|
5166
5611
|
authType: "AK",
|
|
5167
5612
|
style: "RPC",
|
|
5168
|
-
reqBodyType: "
|
|
5613
|
+
reqBodyType: "formData",
|
|
5169
5614
|
bodyType: "json",
|
|
5170
5615
|
});
|
|
5171
5616
|
return $tea.cast(await this.callApi(params, req, runtime), new GetDirectorySAMLServiceProviderInfoResponse({}));
|
|
@@ -5177,10 +5622,11 @@ class Client extends openapi_client_1.default {
|
|
|
5177
5622
|
async getDirectoryStatisticsWithOptions(request, runtime) {
|
|
5178
5623
|
tea_util_1.default.validateModel(request);
|
|
5179
5624
|
let query = {};
|
|
5180
|
-
|
|
5625
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5626
|
+
query["DirectoryId"] = request.directoryId;
|
|
5627
|
+
}
|
|
5181
5628
|
let req = new $OpenApi.OpenApiRequest({
|
|
5182
5629
|
query: openapi_util_1.default.query(query),
|
|
5183
|
-
body: tea_util_1.default.toMap(request),
|
|
5184
5630
|
});
|
|
5185
5631
|
let params = new $OpenApi.Params({
|
|
5186
5632
|
action: "GetDirectoryStatistics",
|
|
@@ -5190,7 +5636,7 @@ class Client extends openapi_client_1.default {
|
|
|
5190
5636
|
method: "POST",
|
|
5191
5637
|
authType: "AK",
|
|
5192
5638
|
style: "RPC",
|
|
5193
|
-
reqBodyType: "
|
|
5639
|
+
reqBodyType: "formData",
|
|
5194
5640
|
bodyType: "json",
|
|
5195
5641
|
});
|
|
5196
5642
|
return $tea.cast(await this.callApi(params, req, runtime), new GetDirectoryStatisticsResponse({}));
|
|
@@ -5202,10 +5648,11 @@ class Client extends openapi_client_1.default {
|
|
|
5202
5648
|
async getExternalSAMLIdentityProviderWithOptions(request, runtime) {
|
|
5203
5649
|
tea_util_1.default.validateModel(request);
|
|
5204
5650
|
let query = {};
|
|
5205
|
-
|
|
5651
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5652
|
+
query["DirectoryId"] = request.directoryId;
|
|
5653
|
+
}
|
|
5206
5654
|
let req = new $OpenApi.OpenApiRequest({
|
|
5207
5655
|
query: openapi_util_1.default.query(query),
|
|
5208
|
-
body: tea_util_1.default.toMap(request),
|
|
5209
5656
|
});
|
|
5210
5657
|
let params = new $OpenApi.Params({
|
|
5211
5658
|
action: "GetExternalSAMLIdentityProvider",
|
|
@@ -5215,7 +5662,7 @@ class Client extends openapi_client_1.default {
|
|
|
5215
5662
|
method: "POST",
|
|
5216
5663
|
authType: "AK",
|
|
5217
5664
|
style: "RPC",
|
|
5218
|
-
reqBodyType: "
|
|
5665
|
+
reqBodyType: "formData",
|
|
5219
5666
|
bodyType: "json",
|
|
5220
5667
|
});
|
|
5221
5668
|
return $tea.cast(await this.callApi(params, req, runtime), new GetExternalSAMLIdentityProviderResponse({}));
|
|
@@ -5227,11 +5674,14 @@ class Client extends openapi_client_1.default {
|
|
|
5227
5674
|
async getGroupWithOptions(request, runtime) {
|
|
5228
5675
|
tea_util_1.default.validateModel(request);
|
|
5229
5676
|
let query = {};
|
|
5230
|
-
|
|
5231
|
-
|
|
5677
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5678
|
+
query["DirectoryId"] = request.directoryId;
|
|
5679
|
+
}
|
|
5680
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
5681
|
+
query["GroupId"] = request.groupId;
|
|
5682
|
+
}
|
|
5232
5683
|
let req = new $OpenApi.OpenApiRequest({
|
|
5233
5684
|
query: openapi_util_1.default.query(query),
|
|
5234
|
-
body: tea_util_1.default.toMap(request),
|
|
5235
5685
|
});
|
|
5236
5686
|
let params = new $OpenApi.Params({
|
|
5237
5687
|
action: "GetGroup",
|
|
@@ -5241,7 +5691,7 @@ class Client extends openapi_client_1.default {
|
|
|
5241
5691
|
method: "POST",
|
|
5242
5692
|
authType: "AK",
|
|
5243
5693
|
style: "RPC",
|
|
5244
|
-
reqBodyType: "
|
|
5694
|
+
reqBodyType: "formData",
|
|
5245
5695
|
bodyType: "json",
|
|
5246
5696
|
});
|
|
5247
5697
|
return $tea.cast(await this.callApi(params, req, runtime), new GetGroupResponse({}));
|
|
@@ -5250,13 +5700,40 @@ class Client extends openapi_client_1.default {
|
|
|
5250
5700
|
let runtime = new $Util.RuntimeOptions({});
|
|
5251
5701
|
return await this.getGroupWithOptions(request, runtime);
|
|
5252
5702
|
}
|
|
5703
|
+
async getMFAAuthenticationSettingsWithOptions(request, runtime) {
|
|
5704
|
+
tea_util_1.default.validateModel(request);
|
|
5705
|
+
let query = {};
|
|
5706
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5707
|
+
query["DirectoryId"] = request.directoryId;
|
|
5708
|
+
}
|
|
5709
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
5710
|
+
query: openapi_util_1.default.query(query),
|
|
5711
|
+
});
|
|
5712
|
+
let params = new $OpenApi.Params({
|
|
5713
|
+
action: "GetMFAAuthenticationSettings",
|
|
5714
|
+
version: "2021-05-15",
|
|
5715
|
+
protocol: "HTTPS",
|
|
5716
|
+
pathname: "/",
|
|
5717
|
+
method: "POST",
|
|
5718
|
+
authType: "AK",
|
|
5719
|
+
style: "RPC",
|
|
5720
|
+
reqBodyType: "formData",
|
|
5721
|
+
bodyType: "json",
|
|
5722
|
+
});
|
|
5723
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetMFAAuthenticationSettingsResponse({}));
|
|
5724
|
+
}
|
|
5725
|
+
async getMFAAuthenticationSettings(request) {
|
|
5726
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
5727
|
+
return await this.getMFAAuthenticationSettingsWithOptions(request, runtime);
|
|
5728
|
+
}
|
|
5253
5729
|
async getMFAAuthenticationStatusWithOptions(request, runtime) {
|
|
5254
5730
|
tea_util_1.default.validateModel(request);
|
|
5255
5731
|
let query = {};
|
|
5256
|
-
|
|
5732
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5733
|
+
query["DirectoryId"] = request.directoryId;
|
|
5734
|
+
}
|
|
5257
5735
|
let req = new $OpenApi.OpenApiRequest({
|
|
5258
5736
|
query: openapi_util_1.default.query(query),
|
|
5259
|
-
body: tea_util_1.default.toMap(request),
|
|
5260
5737
|
});
|
|
5261
5738
|
let params = new $OpenApi.Params({
|
|
5262
5739
|
action: "GetMFAAuthenticationStatus",
|
|
@@ -5266,7 +5743,7 @@ class Client extends openapi_client_1.default {
|
|
|
5266
5743
|
method: "POST",
|
|
5267
5744
|
authType: "AK",
|
|
5268
5745
|
style: "RPC",
|
|
5269
|
-
reqBodyType: "
|
|
5746
|
+
reqBodyType: "formData",
|
|
5270
5747
|
bodyType: "json",
|
|
5271
5748
|
});
|
|
5272
5749
|
return $tea.cast(await this.callApi(params, req, runtime), new GetMFAAuthenticationStatusResponse({}));
|
|
@@ -5278,10 +5755,11 @@ class Client extends openapi_client_1.default {
|
|
|
5278
5755
|
async getSCIMSynchronizationStatusWithOptions(request, runtime) {
|
|
5279
5756
|
tea_util_1.default.validateModel(request);
|
|
5280
5757
|
let query = {};
|
|
5281
|
-
|
|
5758
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5759
|
+
query["DirectoryId"] = request.directoryId;
|
|
5760
|
+
}
|
|
5282
5761
|
let req = new $OpenApi.OpenApiRequest({
|
|
5283
5762
|
query: openapi_util_1.default.query(query),
|
|
5284
|
-
body: tea_util_1.default.toMap(request),
|
|
5285
5763
|
});
|
|
5286
5764
|
let params = new $OpenApi.Params({
|
|
5287
5765
|
action: "GetSCIMSynchronizationStatus",
|
|
@@ -5291,7 +5769,7 @@ class Client extends openapi_client_1.default {
|
|
|
5291
5769
|
method: "POST",
|
|
5292
5770
|
authType: "AK",
|
|
5293
5771
|
style: "RPC",
|
|
5294
|
-
reqBodyType: "
|
|
5772
|
+
reqBodyType: "formData",
|
|
5295
5773
|
bodyType: "json",
|
|
5296
5774
|
});
|
|
5297
5775
|
return $tea.cast(await this.callApi(params, req, runtime), new GetSCIMSynchronizationStatusResponse({}));
|
|
@@ -5310,7 +5788,7 @@ class Client extends openapi_client_1.default {
|
|
|
5310
5788
|
method: "POST",
|
|
5311
5789
|
authType: "AK",
|
|
5312
5790
|
style: "RPC",
|
|
5313
|
-
reqBodyType: "
|
|
5791
|
+
reqBodyType: "formData",
|
|
5314
5792
|
bodyType: "json",
|
|
5315
5793
|
});
|
|
5316
5794
|
return $tea.cast(await this.callApi(params, req, runtime), new GetServiceStatusResponse({}));
|
|
@@ -5322,11 +5800,14 @@ class Client extends openapi_client_1.default {
|
|
|
5322
5800
|
async getTaskWithOptions(request, runtime) {
|
|
5323
5801
|
tea_util_1.default.validateModel(request);
|
|
5324
5802
|
let query = {};
|
|
5325
|
-
|
|
5326
|
-
|
|
5803
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5804
|
+
query["DirectoryId"] = request.directoryId;
|
|
5805
|
+
}
|
|
5806
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
5807
|
+
query["TaskId"] = request.taskId;
|
|
5808
|
+
}
|
|
5327
5809
|
let req = new $OpenApi.OpenApiRequest({
|
|
5328
5810
|
query: openapi_util_1.default.query(query),
|
|
5329
|
-
body: tea_util_1.default.toMap(request),
|
|
5330
5811
|
});
|
|
5331
5812
|
let params = new $OpenApi.Params({
|
|
5332
5813
|
action: "GetTask",
|
|
@@ -5336,7 +5817,7 @@ class Client extends openapi_client_1.default {
|
|
|
5336
5817
|
method: "POST",
|
|
5337
5818
|
authType: "AK",
|
|
5338
5819
|
style: "RPC",
|
|
5339
|
-
reqBodyType: "
|
|
5820
|
+
reqBodyType: "formData",
|
|
5340
5821
|
bodyType: "json",
|
|
5341
5822
|
});
|
|
5342
5823
|
return $tea.cast(await this.callApi(params, req, runtime), new GetTaskResponse({}));
|
|
@@ -5348,11 +5829,14 @@ class Client extends openapi_client_1.default {
|
|
|
5348
5829
|
async getTaskStatusWithOptions(request, runtime) {
|
|
5349
5830
|
tea_util_1.default.validateModel(request);
|
|
5350
5831
|
let query = {};
|
|
5351
|
-
|
|
5352
|
-
|
|
5832
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5833
|
+
query["DirectoryId"] = request.directoryId;
|
|
5834
|
+
}
|
|
5835
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
5836
|
+
query["TaskId"] = request.taskId;
|
|
5837
|
+
}
|
|
5353
5838
|
let req = new $OpenApi.OpenApiRequest({
|
|
5354
5839
|
query: openapi_util_1.default.query(query),
|
|
5355
|
-
body: tea_util_1.default.toMap(request),
|
|
5356
5840
|
});
|
|
5357
5841
|
let params = new $OpenApi.Params({
|
|
5358
5842
|
action: "GetTaskStatus",
|
|
@@ -5362,7 +5846,7 @@ class Client extends openapi_client_1.default {
|
|
|
5362
5846
|
method: "POST",
|
|
5363
5847
|
authType: "AK",
|
|
5364
5848
|
style: "RPC",
|
|
5365
|
-
reqBodyType: "
|
|
5849
|
+
reqBodyType: "formData",
|
|
5366
5850
|
bodyType: "json",
|
|
5367
5851
|
});
|
|
5368
5852
|
return $tea.cast(await this.callApi(params, req, runtime), new GetTaskStatusResponse({}));
|
|
@@ -5374,11 +5858,14 @@ class Client extends openapi_client_1.default {
|
|
|
5374
5858
|
async getUserWithOptions(request, runtime) {
|
|
5375
5859
|
tea_util_1.default.validateModel(request);
|
|
5376
5860
|
let query = {};
|
|
5377
|
-
|
|
5378
|
-
|
|
5861
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5862
|
+
query["DirectoryId"] = request.directoryId;
|
|
5863
|
+
}
|
|
5864
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
5865
|
+
query["UserId"] = request.userId;
|
|
5866
|
+
}
|
|
5379
5867
|
let req = new $OpenApi.OpenApiRequest({
|
|
5380
5868
|
query: openapi_util_1.default.query(query),
|
|
5381
|
-
body: tea_util_1.default.toMap(request),
|
|
5382
5869
|
});
|
|
5383
5870
|
let params = new $OpenApi.Params({
|
|
5384
5871
|
action: "GetUser",
|
|
@@ -5388,7 +5875,7 @@ class Client extends openapi_client_1.default {
|
|
|
5388
5875
|
method: "POST",
|
|
5389
5876
|
authType: "AK",
|
|
5390
5877
|
style: "RPC",
|
|
5391
|
-
reqBodyType: "
|
|
5878
|
+
reqBodyType: "formData",
|
|
5392
5879
|
bodyType: "json",
|
|
5393
5880
|
});
|
|
5394
5881
|
return $tea.cast(await this.callApi(params, req, runtime), new GetUserResponse({}));
|
|
@@ -5397,20 +5884,64 @@ class Client extends openapi_client_1.default {
|
|
|
5397
5884
|
let runtime = new $Util.RuntimeOptions({});
|
|
5398
5885
|
return await this.getUserWithOptions(request, runtime);
|
|
5399
5886
|
}
|
|
5887
|
+
async getUserMFAAuthenticationSettingsWithOptions(request, runtime) {
|
|
5888
|
+
tea_util_1.default.validateModel(request);
|
|
5889
|
+
let query = {};
|
|
5890
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5891
|
+
query["DirectoryId"] = request.directoryId;
|
|
5892
|
+
}
|
|
5893
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
5894
|
+
query["UserId"] = request.userId;
|
|
5895
|
+
}
|
|
5896
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
5897
|
+
query: openapi_util_1.default.query(query),
|
|
5898
|
+
});
|
|
5899
|
+
let params = new $OpenApi.Params({
|
|
5900
|
+
action: "GetUserMFAAuthenticationSettings",
|
|
5901
|
+
version: "2021-05-15",
|
|
5902
|
+
protocol: "HTTPS",
|
|
5903
|
+
pathname: "/",
|
|
5904
|
+
method: "POST",
|
|
5905
|
+
authType: "AK",
|
|
5906
|
+
style: "RPC",
|
|
5907
|
+
reqBodyType: "formData",
|
|
5908
|
+
bodyType: "json",
|
|
5909
|
+
});
|
|
5910
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetUserMFAAuthenticationSettingsResponse({}));
|
|
5911
|
+
}
|
|
5912
|
+
async getUserMFAAuthenticationSettings(request) {
|
|
5913
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
5914
|
+
return await this.getUserMFAAuthenticationSettingsWithOptions(request, runtime);
|
|
5915
|
+
}
|
|
5400
5916
|
async listAccessAssignmentsWithOptions(request, runtime) {
|
|
5401
5917
|
tea_util_1.default.validateModel(request);
|
|
5402
5918
|
let query = {};
|
|
5403
|
-
|
|
5404
|
-
|
|
5405
|
-
|
|
5406
|
-
|
|
5407
|
-
|
|
5408
|
-
|
|
5409
|
-
|
|
5410
|
-
|
|
5919
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5920
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5921
|
+
}
|
|
5922
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5923
|
+
query["DirectoryId"] = request.directoryId;
|
|
5924
|
+
}
|
|
5925
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
5926
|
+
query["MaxResults"] = request.maxResults;
|
|
5927
|
+
}
|
|
5928
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
5929
|
+
query["NextToken"] = request.nextToken;
|
|
5930
|
+
}
|
|
5931
|
+
if (!tea_util_1.default.isUnset(request.principalId)) {
|
|
5932
|
+
query["PrincipalId"] = request.principalId;
|
|
5933
|
+
}
|
|
5934
|
+
if (!tea_util_1.default.isUnset(request.principalType)) {
|
|
5935
|
+
query["PrincipalType"] = request.principalType;
|
|
5936
|
+
}
|
|
5937
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5938
|
+
query["TargetId"] = request.targetId;
|
|
5939
|
+
}
|
|
5940
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5941
|
+
query["TargetType"] = request.targetType;
|
|
5942
|
+
}
|
|
5411
5943
|
let req = new $OpenApi.OpenApiRequest({
|
|
5412
5944
|
query: openapi_util_1.default.query(query),
|
|
5413
|
-
body: tea_util_1.default.toMap(request),
|
|
5414
5945
|
});
|
|
5415
5946
|
let params = new $OpenApi.Params({
|
|
5416
5947
|
action: "ListAccessAssignments",
|
|
@@ -5420,7 +5951,7 @@ class Client extends openapi_client_1.default {
|
|
|
5420
5951
|
method: "POST",
|
|
5421
5952
|
authType: "AK",
|
|
5422
5953
|
style: "RPC",
|
|
5423
|
-
reqBodyType: "
|
|
5954
|
+
reqBodyType: "formData",
|
|
5424
5955
|
bodyType: "json",
|
|
5425
5956
|
});
|
|
5426
5957
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAccessAssignmentsResponse({}));
|
|
@@ -5432,16 +5963,29 @@ class Client extends openapi_client_1.default {
|
|
|
5432
5963
|
async listAccessConfigurationProvisioningsWithOptions(request, runtime) {
|
|
5433
5964
|
tea_util_1.default.validateModel(request);
|
|
5434
5965
|
let query = {};
|
|
5435
|
-
|
|
5436
|
-
|
|
5437
|
-
|
|
5438
|
-
|
|
5439
|
-
|
|
5440
|
-
|
|
5441
|
-
|
|
5966
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5967
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5968
|
+
}
|
|
5969
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5970
|
+
query["DirectoryId"] = request.directoryId;
|
|
5971
|
+
}
|
|
5972
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
5973
|
+
query["MaxResults"] = request.maxResults;
|
|
5974
|
+
}
|
|
5975
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
5976
|
+
query["NextToken"] = request.nextToken;
|
|
5977
|
+
}
|
|
5978
|
+
if (!tea_util_1.default.isUnset(request.provisioningStatus)) {
|
|
5979
|
+
query["ProvisioningStatus"] = request.provisioningStatus;
|
|
5980
|
+
}
|
|
5981
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5982
|
+
query["TargetId"] = request.targetId;
|
|
5983
|
+
}
|
|
5984
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5985
|
+
query["TargetType"] = request.targetType;
|
|
5986
|
+
}
|
|
5442
5987
|
let req = new $OpenApi.OpenApiRequest({
|
|
5443
5988
|
query: openapi_util_1.default.query(query),
|
|
5444
|
-
body: tea_util_1.default.toMap(request),
|
|
5445
5989
|
});
|
|
5446
5990
|
let params = new $OpenApi.Params({
|
|
5447
5991
|
action: "ListAccessConfigurationProvisionings",
|
|
@@ -5451,7 +5995,7 @@ class Client extends openapi_client_1.default {
|
|
|
5451
5995
|
method: "POST",
|
|
5452
5996
|
authType: "AK",
|
|
5453
5997
|
style: "RPC",
|
|
5454
|
-
reqBodyType: "
|
|
5998
|
+
reqBodyType: "formData",
|
|
5455
5999
|
bodyType: "json",
|
|
5456
6000
|
});
|
|
5457
6001
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAccessConfigurationProvisioningsResponse({}));
|
|
@@ -5463,14 +6007,23 @@ class Client extends openapi_client_1.default {
|
|
|
5463
6007
|
async listAccessConfigurationsWithOptions(request, runtime) {
|
|
5464
6008
|
tea_util_1.default.validateModel(request);
|
|
5465
6009
|
let query = {};
|
|
5466
|
-
|
|
5467
|
-
|
|
5468
|
-
|
|
5469
|
-
|
|
5470
|
-
|
|
6010
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6011
|
+
query["DirectoryId"] = request.directoryId;
|
|
6012
|
+
}
|
|
6013
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
6014
|
+
query["Filter"] = request.filter;
|
|
6015
|
+
}
|
|
6016
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6017
|
+
query["MaxResults"] = request.maxResults;
|
|
6018
|
+
}
|
|
6019
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6020
|
+
query["NextToken"] = request.nextToken;
|
|
6021
|
+
}
|
|
6022
|
+
if (!tea_util_1.default.isUnset(request.statusNotifications)) {
|
|
6023
|
+
query["StatusNotifications"] = request.statusNotifications;
|
|
6024
|
+
}
|
|
5471
6025
|
let req = new $OpenApi.OpenApiRequest({
|
|
5472
6026
|
query: openapi_util_1.default.query(query),
|
|
5473
|
-
body: tea_util_1.default.toMap(request),
|
|
5474
6027
|
});
|
|
5475
6028
|
let params = new $OpenApi.Params({
|
|
5476
6029
|
action: "ListAccessConfigurations",
|
|
@@ -5480,7 +6033,7 @@ class Client extends openapi_client_1.default {
|
|
|
5480
6033
|
method: "POST",
|
|
5481
6034
|
authType: "AK",
|
|
5482
6035
|
style: "RPC",
|
|
5483
|
-
reqBodyType: "
|
|
6036
|
+
reqBodyType: "formData",
|
|
5484
6037
|
bodyType: "json",
|
|
5485
6038
|
});
|
|
5486
6039
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAccessConfigurationsResponse({}));
|
|
@@ -5499,7 +6052,7 @@ class Client extends openapi_client_1.default {
|
|
|
5499
6052
|
method: "POST",
|
|
5500
6053
|
authType: "AK",
|
|
5501
6054
|
style: "RPC",
|
|
5502
|
-
reqBodyType: "
|
|
6055
|
+
reqBodyType: "formData",
|
|
5503
6056
|
bodyType: "json",
|
|
5504
6057
|
});
|
|
5505
6058
|
return $tea.cast(await this.callApi(params, req, runtime), new ListDirectoriesResponse({}));
|
|
@@ -5511,10 +6064,11 @@ class Client extends openapi_client_1.default {
|
|
|
5511
6064
|
async listExternalSAMLIdPCertificatesWithOptions(request, runtime) {
|
|
5512
6065
|
tea_util_1.default.validateModel(request);
|
|
5513
6066
|
let query = {};
|
|
5514
|
-
|
|
6067
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6068
|
+
query["DirectoryId"] = request.directoryId;
|
|
6069
|
+
}
|
|
5515
6070
|
let req = new $OpenApi.OpenApiRequest({
|
|
5516
6071
|
query: openapi_util_1.default.query(query),
|
|
5517
|
-
body: tea_util_1.default.toMap(request),
|
|
5518
6072
|
});
|
|
5519
6073
|
let params = new $OpenApi.Params({
|
|
5520
6074
|
action: "ListExternalSAMLIdPCertificates",
|
|
@@ -5524,7 +6078,7 @@ class Client extends openapi_client_1.default {
|
|
|
5524
6078
|
method: "POST",
|
|
5525
6079
|
authType: "AK",
|
|
5526
6080
|
style: "RPC",
|
|
5527
|
-
reqBodyType: "
|
|
6081
|
+
reqBodyType: "formData",
|
|
5528
6082
|
bodyType: "json",
|
|
5529
6083
|
});
|
|
5530
6084
|
return $tea.cast(await this.callApi(params, req, runtime), new ListExternalSAMLIdPCertificatesResponse({}));
|
|
@@ -5536,13 +6090,20 @@ class Client extends openapi_client_1.default {
|
|
|
5536
6090
|
async listGroupMembersWithOptions(request, runtime) {
|
|
5537
6091
|
tea_util_1.default.validateModel(request);
|
|
5538
6092
|
let query = {};
|
|
5539
|
-
|
|
5540
|
-
|
|
5541
|
-
|
|
5542
|
-
|
|
6093
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6094
|
+
query["DirectoryId"] = request.directoryId;
|
|
6095
|
+
}
|
|
6096
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
6097
|
+
query["GroupId"] = request.groupId;
|
|
6098
|
+
}
|
|
6099
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6100
|
+
query["MaxResults"] = request.maxResults;
|
|
6101
|
+
}
|
|
6102
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6103
|
+
query["NextToken"] = request.nextToken;
|
|
6104
|
+
}
|
|
5543
6105
|
let req = new $OpenApi.OpenApiRequest({
|
|
5544
6106
|
query: openapi_util_1.default.query(query),
|
|
5545
|
-
body: tea_util_1.default.toMap(request),
|
|
5546
6107
|
});
|
|
5547
6108
|
let params = new $OpenApi.Params({
|
|
5548
6109
|
action: "ListGroupMembers",
|
|
@@ -5552,7 +6113,7 @@ class Client extends openapi_client_1.default {
|
|
|
5552
6113
|
method: "POST",
|
|
5553
6114
|
authType: "AK",
|
|
5554
6115
|
style: "RPC",
|
|
5555
|
-
reqBodyType: "
|
|
6116
|
+
reqBodyType: "formData",
|
|
5556
6117
|
bodyType: "json",
|
|
5557
6118
|
});
|
|
5558
6119
|
return $tea.cast(await this.callApi(params, req, runtime), new ListGroupMembersResponse({}));
|
|
@@ -5564,14 +6125,23 @@ class Client extends openapi_client_1.default {
|
|
|
5564
6125
|
async listGroupsWithOptions(request, runtime) {
|
|
5565
6126
|
tea_util_1.default.validateModel(request);
|
|
5566
6127
|
let query = {};
|
|
5567
|
-
|
|
5568
|
-
|
|
5569
|
-
|
|
5570
|
-
|
|
5571
|
-
|
|
6128
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6129
|
+
query["DirectoryId"] = request.directoryId;
|
|
6130
|
+
}
|
|
6131
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
6132
|
+
query["Filter"] = request.filter;
|
|
6133
|
+
}
|
|
6134
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6135
|
+
query["MaxResults"] = request.maxResults;
|
|
6136
|
+
}
|
|
6137
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6138
|
+
query["NextToken"] = request.nextToken;
|
|
6139
|
+
}
|
|
6140
|
+
if (!tea_util_1.default.isUnset(request.provisionType)) {
|
|
6141
|
+
query["ProvisionType"] = request.provisionType;
|
|
6142
|
+
}
|
|
5572
6143
|
let req = new $OpenApi.OpenApiRequest({
|
|
5573
6144
|
query: openapi_util_1.default.query(query),
|
|
5574
|
-
body: tea_util_1.default.toMap(request),
|
|
5575
6145
|
});
|
|
5576
6146
|
let params = new $OpenApi.Params({
|
|
5577
6147
|
action: "ListGroups",
|
|
@@ -5581,7 +6151,7 @@ class Client extends openapi_client_1.default {
|
|
|
5581
6151
|
method: "POST",
|
|
5582
6152
|
authType: "AK",
|
|
5583
6153
|
style: "RPC",
|
|
5584
|
-
reqBodyType: "
|
|
6154
|
+
reqBodyType: "formData",
|
|
5585
6155
|
bodyType: "json",
|
|
5586
6156
|
});
|
|
5587
6157
|
return $tea.cast(await this.callApi(params, req, runtime), new ListGroupsResponse({}));
|
|
@@ -5593,13 +6163,20 @@ class Client extends openapi_client_1.default {
|
|
|
5593
6163
|
async listJoinedGroupsForUserWithOptions(request, runtime) {
|
|
5594
6164
|
tea_util_1.default.validateModel(request);
|
|
5595
6165
|
let query = {};
|
|
5596
|
-
|
|
5597
|
-
|
|
5598
|
-
|
|
5599
|
-
|
|
6166
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6167
|
+
query["DirectoryId"] = request.directoryId;
|
|
6168
|
+
}
|
|
6169
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6170
|
+
query["MaxResults"] = request.maxResults;
|
|
6171
|
+
}
|
|
6172
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6173
|
+
query["NextToken"] = request.nextToken;
|
|
6174
|
+
}
|
|
6175
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6176
|
+
query["UserId"] = request.userId;
|
|
6177
|
+
}
|
|
5600
6178
|
let req = new $OpenApi.OpenApiRequest({
|
|
5601
6179
|
query: openapi_util_1.default.query(query),
|
|
5602
|
-
body: tea_util_1.default.toMap(request),
|
|
5603
6180
|
});
|
|
5604
6181
|
let params = new $OpenApi.Params({
|
|
5605
6182
|
action: "ListJoinedGroupsForUser",
|
|
@@ -5609,7 +6186,7 @@ class Client extends openapi_client_1.default {
|
|
|
5609
6186
|
method: "POST",
|
|
5610
6187
|
authType: "AK",
|
|
5611
6188
|
style: "RPC",
|
|
5612
|
-
reqBodyType: "
|
|
6189
|
+
reqBodyType: "formData",
|
|
5613
6190
|
bodyType: "json",
|
|
5614
6191
|
});
|
|
5615
6192
|
return $tea.cast(await this.callApi(params, req, runtime), new ListJoinedGroupsForUserResponse({}));
|
|
@@ -5621,11 +6198,14 @@ class Client extends openapi_client_1.default {
|
|
|
5621
6198
|
async listMFADevicesForUserWithOptions(request, runtime) {
|
|
5622
6199
|
tea_util_1.default.validateModel(request);
|
|
5623
6200
|
let query = {};
|
|
5624
|
-
|
|
5625
|
-
|
|
6201
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6202
|
+
query["DirectoryId"] = request.directoryId;
|
|
6203
|
+
}
|
|
6204
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6205
|
+
query["UserId"] = request.userId;
|
|
6206
|
+
}
|
|
5626
6207
|
let req = new $OpenApi.OpenApiRequest({
|
|
5627
6208
|
query: openapi_util_1.default.query(query),
|
|
5628
|
-
body: tea_util_1.default.toMap(request),
|
|
5629
6209
|
});
|
|
5630
6210
|
let params = new $OpenApi.Params({
|
|
5631
6211
|
action: "ListMFADevicesForUser",
|
|
@@ -5635,7 +6215,7 @@ class Client extends openapi_client_1.default {
|
|
|
5635
6215
|
method: "POST",
|
|
5636
6216
|
authType: "AK",
|
|
5637
6217
|
style: "RPC",
|
|
5638
|
-
reqBodyType: "
|
|
6218
|
+
reqBodyType: "formData",
|
|
5639
6219
|
bodyType: "json",
|
|
5640
6220
|
});
|
|
5641
6221
|
return $tea.cast(await this.callApi(params, req, runtime), new ListMFADevicesForUserResponse({}));
|
|
@@ -5647,12 +6227,17 @@ class Client extends openapi_client_1.default {
|
|
|
5647
6227
|
async listPermissionPoliciesInAccessConfigurationWithOptions(request, runtime) {
|
|
5648
6228
|
tea_util_1.default.validateModel(request);
|
|
5649
6229
|
let query = {};
|
|
5650
|
-
|
|
5651
|
-
|
|
5652
|
-
|
|
6230
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6231
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6232
|
+
}
|
|
6233
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6234
|
+
query["DirectoryId"] = request.directoryId;
|
|
6235
|
+
}
|
|
6236
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyType)) {
|
|
6237
|
+
query["PermissionPolicyType"] = request.permissionPolicyType;
|
|
6238
|
+
}
|
|
5653
6239
|
let req = new $OpenApi.OpenApiRequest({
|
|
5654
6240
|
query: openapi_util_1.default.query(query),
|
|
5655
|
-
body: tea_util_1.default.toMap(request),
|
|
5656
6241
|
});
|
|
5657
6242
|
let params = new $OpenApi.Params({
|
|
5658
6243
|
action: "ListPermissionPoliciesInAccessConfiguration",
|
|
@@ -5662,7 +6247,7 @@ class Client extends openapi_client_1.default {
|
|
|
5662
6247
|
method: "POST",
|
|
5663
6248
|
authType: "AK",
|
|
5664
6249
|
style: "RPC",
|
|
5665
|
-
reqBodyType: "
|
|
6250
|
+
reqBodyType: "formData",
|
|
5666
6251
|
bodyType: "json",
|
|
5667
6252
|
});
|
|
5668
6253
|
return $tea.cast(await this.callApi(params, req, runtime), new ListPermissionPoliciesInAccessConfigurationResponse({}));
|
|
@@ -5674,10 +6259,11 @@ class Client extends openapi_client_1.default {
|
|
|
5674
6259
|
async listSCIMServerCredentialsWithOptions(request, runtime) {
|
|
5675
6260
|
tea_util_1.default.validateModel(request);
|
|
5676
6261
|
let query = {};
|
|
5677
|
-
|
|
6262
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6263
|
+
query["DirectoryId"] = request.directoryId;
|
|
6264
|
+
}
|
|
5678
6265
|
let req = new $OpenApi.OpenApiRequest({
|
|
5679
6266
|
query: openapi_util_1.default.query(query),
|
|
5680
|
-
body: tea_util_1.default.toMap(request),
|
|
5681
6267
|
});
|
|
5682
6268
|
let params = new $OpenApi.Params({
|
|
5683
6269
|
action: "ListSCIMServerCredentials",
|
|
@@ -5687,7 +6273,7 @@ class Client extends openapi_client_1.default {
|
|
|
5687
6273
|
method: "POST",
|
|
5688
6274
|
authType: "AK",
|
|
5689
6275
|
style: "RPC",
|
|
5690
|
-
reqBodyType: "
|
|
6276
|
+
reqBodyType: "formData",
|
|
5691
6277
|
bodyType: "json",
|
|
5692
6278
|
});
|
|
5693
6279
|
return $tea.cast(await this.callApi(params, req, runtime), new ListSCIMServerCredentialsResponse({}));
|
|
@@ -5699,20 +6285,41 @@ class Client extends openapi_client_1.default {
|
|
|
5699
6285
|
async listTasksWithOptions(request, runtime) {
|
|
5700
6286
|
tea_util_1.default.validateModel(request);
|
|
5701
6287
|
let query = {};
|
|
5702
|
-
|
|
5703
|
-
|
|
5704
|
-
|
|
5705
|
-
|
|
5706
|
-
|
|
5707
|
-
|
|
5708
|
-
|
|
5709
|
-
|
|
5710
|
-
|
|
5711
|
-
|
|
5712
|
-
|
|
6288
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6289
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6290
|
+
}
|
|
6291
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6292
|
+
query["DirectoryId"] = request.directoryId;
|
|
6293
|
+
}
|
|
6294
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
6295
|
+
query["Filter"] = request.filter;
|
|
6296
|
+
}
|
|
6297
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6298
|
+
query["MaxResults"] = request.maxResults;
|
|
6299
|
+
}
|
|
6300
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6301
|
+
query["NextToken"] = request.nextToken;
|
|
6302
|
+
}
|
|
6303
|
+
if (!tea_util_1.default.isUnset(request.principalId)) {
|
|
6304
|
+
query["PrincipalId"] = request.principalId;
|
|
6305
|
+
}
|
|
6306
|
+
if (!tea_util_1.default.isUnset(request.principalType)) {
|
|
6307
|
+
query["PrincipalType"] = request.principalType;
|
|
6308
|
+
}
|
|
6309
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
6310
|
+
query["Status"] = request.status;
|
|
6311
|
+
}
|
|
6312
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
6313
|
+
query["TargetId"] = request.targetId;
|
|
6314
|
+
}
|
|
6315
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
6316
|
+
query["TargetType"] = request.targetType;
|
|
6317
|
+
}
|
|
6318
|
+
if (!tea_util_1.default.isUnset(request.taskType)) {
|
|
6319
|
+
query["TaskType"] = request.taskType;
|
|
6320
|
+
}
|
|
5713
6321
|
let req = new $OpenApi.OpenApiRequest({
|
|
5714
6322
|
query: openapi_util_1.default.query(query),
|
|
5715
|
-
body: tea_util_1.default.toMap(request),
|
|
5716
6323
|
});
|
|
5717
6324
|
let params = new $OpenApi.Params({
|
|
5718
6325
|
action: "ListTasks",
|
|
@@ -5722,7 +6329,7 @@ class Client extends openapi_client_1.default {
|
|
|
5722
6329
|
method: "POST",
|
|
5723
6330
|
authType: "AK",
|
|
5724
6331
|
style: "RPC",
|
|
5725
|
-
reqBodyType: "
|
|
6332
|
+
reqBodyType: "formData",
|
|
5726
6333
|
bodyType: "json",
|
|
5727
6334
|
});
|
|
5728
6335
|
return $tea.cast(await this.callApi(params, req, runtime), new ListTasksResponse({}));
|
|
@@ -5734,15 +6341,26 @@ class Client extends openapi_client_1.default {
|
|
|
5734
6341
|
async listUsersWithOptions(request, runtime) {
|
|
5735
6342
|
tea_util_1.default.validateModel(request);
|
|
5736
6343
|
let query = {};
|
|
5737
|
-
|
|
5738
|
-
|
|
5739
|
-
|
|
5740
|
-
|
|
5741
|
-
|
|
5742
|
-
|
|
6344
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6345
|
+
query["DirectoryId"] = request.directoryId;
|
|
6346
|
+
}
|
|
6347
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
6348
|
+
query["Filter"] = request.filter;
|
|
6349
|
+
}
|
|
6350
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6351
|
+
query["MaxResults"] = request.maxResults;
|
|
6352
|
+
}
|
|
6353
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6354
|
+
query["NextToken"] = request.nextToken;
|
|
6355
|
+
}
|
|
6356
|
+
if (!tea_util_1.default.isUnset(request.provisionType)) {
|
|
6357
|
+
query["ProvisionType"] = request.provisionType;
|
|
6358
|
+
}
|
|
6359
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
6360
|
+
query["Status"] = request.status;
|
|
6361
|
+
}
|
|
5743
6362
|
let req = new $OpenApi.OpenApiRequest({
|
|
5744
6363
|
query: openapi_util_1.default.query(query),
|
|
5745
|
-
body: tea_util_1.default.toMap(request),
|
|
5746
6364
|
});
|
|
5747
6365
|
let params = new $OpenApi.Params({
|
|
5748
6366
|
action: "ListUsers",
|
|
@@ -5752,7 +6370,7 @@ class Client extends openapi_client_1.default {
|
|
|
5752
6370
|
method: "POST",
|
|
5753
6371
|
authType: "AK",
|
|
5754
6372
|
style: "RPC",
|
|
5755
|
-
reqBodyType: "
|
|
6373
|
+
reqBodyType: "formData",
|
|
5756
6374
|
bodyType: "json",
|
|
5757
6375
|
});
|
|
5758
6376
|
return $tea.cast(await this.callApi(params, req, runtime), new ListUsersResponse({}));
|
|
@@ -5764,13 +6382,20 @@ class Client extends openapi_client_1.default {
|
|
|
5764
6382
|
async provisionAccessConfigurationWithOptions(request, runtime) {
|
|
5765
6383
|
tea_util_1.default.validateModel(request);
|
|
5766
6384
|
let query = {};
|
|
5767
|
-
|
|
5768
|
-
|
|
5769
|
-
|
|
5770
|
-
|
|
6385
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6386
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6387
|
+
}
|
|
6388
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6389
|
+
query["DirectoryId"] = request.directoryId;
|
|
6390
|
+
}
|
|
6391
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
6392
|
+
query["TargetId"] = request.targetId;
|
|
6393
|
+
}
|
|
6394
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
6395
|
+
query["TargetType"] = request.targetType;
|
|
6396
|
+
}
|
|
5771
6397
|
let req = new $OpenApi.OpenApiRequest({
|
|
5772
6398
|
query: openapi_util_1.default.query(query),
|
|
5773
|
-
body: tea_util_1.default.toMap(request),
|
|
5774
6399
|
});
|
|
5775
6400
|
let params = new $OpenApi.Params({
|
|
5776
6401
|
action: "ProvisionAccessConfiguration",
|
|
@@ -5780,7 +6405,7 @@ class Client extends openapi_client_1.default {
|
|
|
5780
6405
|
method: "POST",
|
|
5781
6406
|
authType: "AK",
|
|
5782
6407
|
style: "RPC",
|
|
5783
|
-
reqBodyType: "
|
|
6408
|
+
reqBodyType: "formData",
|
|
5784
6409
|
bodyType: "json",
|
|
5785
6410
|
});
|
|
5786
6411
|
return $tea.cast(await this.callApi(params, req, runtime), new ProvisionAccessConfigurationResponse({}));
|
|
@@ -5792,11 +6417,14 @@ class Client extends openapi_client_1.default {
|
|
|
5792
6417
|
async removeExternalSAMLIdPCertificateWithOptions(request, runtime) {
|
|
5793
6418
|
tea_util_1.default.validateModel(request);
|
|
5794
6419
|
let query = {};
|
|
5795
|
-
|
|
5796
|
-
|
|
6420
|
+
if (!tea_util_1.default.isUnset(request.certificateId)) {
|
|
6421
|
+
query["CertificateId"] = request.certificateId;
|
|
6422
|
+
}
|
|
6423
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6424
|
+
query["DirectoryId"] = request.directoryId;
|
|
6425
|
+
}
|
|
5797
6426
|
let req = new $OpenApi.OpenApiRequest({
|
|
5798
6427
|
query: openapi_util_1.default.query(query),
|
|
5799
|
-
body: tea_util_1.default.toMap(request),
|
|
5800
6428
|
});
|
|
5801
6429
|
let params = new $OpenApi.Params({
|
|
5802
6430
|
action: "RemoveExternalSAMLIdPCertificate",
|
|
@@ -5806,7 +6434,7 @@ class Client extends openapi_client_1.default {
|
|
|
5806
6434
|
method: "POST",
|
|
5807
6435
|
authType: "AK",
|
|
5808
6436
|
style: "RPC",
|
|
5809
|
-
reqBodyType: "
|
|
6437
|
+
reqBodyType: "formData",
|
|
5810
6438
|
bodyType: "json",
|
|
5811
6439
|
});
|
|
5812
6440
|
return $tea.cast(await this.callApi(params, req, runtime), new RemoveExternalSAMLIdPCertificateResponse({}));
|
|
@@ -5818,13 +6446,20 @@ class Client extends openapi_client_1.default {
|
|
|
5818
6446
|
async removePermissionPolicyFromAccessConfigurationWithOptions(request, runtime) {
|
|
5819
6447
|
tea_util_1.default.validateModel(request);
|
|
5820
6448
|
let query = {};
|
|
5821
|
-
|
|
5822
|
-
|
|
5823
|
-
|
|
5824
|
-
|
|
6449
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6450
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6451
|
+
}
|
|
6452
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6453
|
+
query["DirectoryId"] = request.directoryId;
|
|
6454
|
+
}
|
|
6455
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyName)) {
|
|
6456
|
+
query["PermissionPolicyName"] = request.permissionPolicyName;
|
|
6457
|
+
}
|
|
6458
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyType)) {
|
|
6459
|
+
query["PermissionPolicyType"] = request.permissionPolicyType;
|
|
6460
|
+
}
|
|
5825
6461
|
let req = new $OpenApi.OpenApiRequest({
|
|
5826
6462
|
query: openapi_util_1.default.query(query),
|
|
5827
|
-
body: tea_util_1.default.toMap(request),
|
|
5828
6463
|
});
|
|
5829
6464
|
let params = new $OpenApi.Params({
|
|
5830
6465
|
action: "RemovePermissionPolicyFromAccessConfiguration",
|
|
@@ -5834,7 +6469,7 @@ class Client extends openapi_client_1.default {
|
|
|
5834
6469
|
method: "POST",
|
|
5835
6470
|
authType: "AK",
|
|
5836
6471
|
style: "RPC",
|
|
5837
|
-
reqBodyType: "
|
|
6472
|
+
reqBodyType: "formData",
|
|
5838
6473
|
bodyType: "json",
|
|
5839
6474
|
});
|
|
5840
6475
|
return $tea.cast(await this.callApi(params, req, runtime), new RemovePermissionPolicyFromAccessConfigurationResponse({}));
|
|
@@ -5846,12 +6481,17 @@ class Client extends openapi_client_1.default {
|
|
|
5846
6481
|
async removeUserFromGroupWithOptions(request, runtime) {
|
|
5847
6482
|
tea_util_1.default.validateModel(request);
|
|
5848
6483
|
let query = {};
|
|
5849
|
-
|
|
5850
|
-
|
|
5851
|
-
|
|
6484
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6485
|
+
query["DirectoryId"] = request.directoryId;
|
|
6486
|
+
}
|
|
6487
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
6488
|
+
query["GroupId"] = request.groupId;
|
|
6489
|
+
}
|
|
6490
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6491
|
+
query["UserId"] = request.userId;
|
|
6492
|
+
}
|
|
5852
6493
|
let req = new $OpenApi.OpenApiRequest({
|
|
5853
6494
|
query: openapi_util_1.default.query(query),
|
|
5854
|
-
body: tea_util_1.default.toMap(request),
|
|
5855
6495
|
});
|
|
5856
6496
|
let params = new $OpenApi.Params({
|
|
5857
6497
|
action: "RemoveUserFromGroup",
|
|
@@ -5861,7 +6501,7 @@ class Client extends openapi_client_1.default {
|
|
|
5861
6501
|
method: "POST",
|
|
5862
6502
|
authType: "AK",
|
|
5863
6503
|
style: "RPC",
|
|
5864
|
-
reqBodyType: "
|
|
6504
|
+
reqBodyType: "formData",
|
|
5865
6505
|
bodyType: "json",
|
|
5866
6506
|
});
|
|
5867
6507
|
return $tea.cast(await this.callApi(params, req, runtime), new RemoveUserFromGroupResponse({}));
|
|
@@ -5873,14 +6513,23 @@ class Client extends openapi_client_1.default {
|
|
|
5873
6513
|
async resetUserPasswordWithOptions(request, runtime) {
|
|
5874
6514
|
tea_util_1.default.validateModel(request);
|
|
5875
6515
|
let query = {};
|
|
5876
|
-
|
|
5877
|
-
|
|
5878
|
-
|
|
5879
|
-
|
|
5880
|
-
|
|
6516
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6517
|
+
query["DirectoryId"] = request.directoryId;
|
|
6518
|
+
}
|
|
6519
|
+
if (!tea_util_1.default.isUnset(request.generateRandomPassword)) {
|
|
6520
|
+
query["GenerateRandomPassword"] = request.generateRandomPassword;
|
|
6521
|
+
}
|
|
6522
|
+
if (!tea_util_1.default.isUnset(request.password)) {
|
|
6523
|
+
query["Password"] = request.password;
|
|
6524
|
+
}
|
|
6525
|
+
if (!tea_util_1.default.isUnset(request.requirePasswordResetForNextLogin)) {
|
|
6526
|
+
query["RequirePasswordResetForNextLogin"] = request.requirePasswordResetForNextLogin;
|
|
6527
|
+
}
|
|
6528
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6529
|
+
query["UserId"] = request.userId;
|
|
6530
|
+
}
|
|
5881
6531
|
let req = new $OpenApi.OpenApiRequest({
|
|
5882
6532
|
query: openapi_util_1.default.query(query),
|
|
5883
|
-
body: tea_util_1.default.toMap(request),
|
|
5884
6533
|
});
|
|
5885
6534
|
let params = new $OpenApi.Params({
|
|
5886
6535
|
action: "ResetUserPassword",
|
|
@@ -5890,7 +6539,7 @@ class Client extends openapi_client_1.default {
|
|
|
5890
6539
|
method: "POST",
|
|
5891
6540
|
authType: "AK",
|
|
5892
6541
|
style: "RPC",
|
|
5893
|
-
reqBodyType: "
|
|
6542
|
+
reqBodyType: "formData",
|
|
5894
6543
|
bodyType: "json",
|
|
5895
6544
|
});
|
|
5896
6545
|
return $tea.cast(await this.callApi(params, req, runtime), new ResetUserPasswordResponse({}));
|
|
@@ -5902,16 +6551,29 @@ class Client extends openapi_client_1.default {
|
|
|
5902
6551
|
async setExternalSAMLIdentityProviderWithOptions(request, runtime) {
|
|
5903
6552
|
tea_util_1.default.validateModel(request);
|
|
5904
6553
|
let query = {};
|
|
5905
|
-
|
|
5906
|
-
|
|
5907
|
-
|
|
5908
|
-
|
|
5909
|
-
|
|
5910
|
-
|
|
5911
|
-
|
|
6554
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6555
|
+
query["DirectoryId"] = request.directoryId;
|
|
6556
|
+
}
|
|
6557
|
+
if (!tea_util_1.default.isUnset(request.encodedMetadataDocument)) {
|
|
6558
|
+
query["EncodedMetadataDocument"] = request.encodedMetadataDocument;
|
|
6559
|
+
}
|
|
6560
|
+
if (!tea_util_1.default.isUnset(request.entityId)) {
|
|
6561
|
+
query["EntityId"] = request.entityId;
|
|
6562
|
+
}
|
|
6563
|
+
if (!tea_util_1.default.isUnset(request.loginUrl)) {
|
|
6564
|
+
query["LoginUrl"] = request.loginUrl;
|
|
6565
|
+
}
|
|
6566
|
+
if (!tea_util_1.default.isUnset(request.SSOStatus)) {
|
|
6567
|
+
query["SSOStatus"] = request.SSOStatus;
|
|
6568
|
+
}
|
|
6569
|
+
if (!tea_util_1.default.isUnset(request.wantRequestSigned)) {
|
|
6570
|
+
query["WantRequestSigned"] = request.wantRequestSigned;
|
|
6571
|
+
}
|
|
6572
|
+
if (!tea_util_1.default.isUnset(request.x509Certificate)) {
|
|
6573
|
+
query["X509Certificate"] = request.x509Certificate;
|
|
6574
|
+
}
|
|
5912
6575
|
let req = new $OpenApi.OpenApiRequest({
|
|
5913
6576
|
query: openapi_util_1.default.query(query),
|
|
5914
|
-
body: tea_util_1.default.toMap(request),
|
|
5915
6577
|
});
|
|
5916
6578
|
let params = new $OpenApi.Params({
|
|
5917
6579
|
action: "SetExternalSAMLIdentityProvider",
|
|
@@ -5921,7 +6583,7 @@ class Client extends openapi_client_1.default {
|
|
|
5921
6583
|
method: "POST",
|
|
5922
6584
|
authType: "AK",
|
|
5923
6585
|
style: "RPC",
|
|
5924
|
-
reqBodyType: "
|
|
6586
|
+
reqBodyType: "formData",
|
|
5925
6587
|
bodyType: "json",
|
|
5926
6588
|
});
|
|
5927
6589
|
return $tea.cast(await this.callApi(params, req, runtime), new SetExternalSAMLIdentityProviderResponse({}));
|
|
@@ -5933,11 +6595,14 @@ class Client extends openapi_client_1.default {
|
|
|
5933
6595
|
async setMFAAuthenticationStatusWithOptions(request, runtime) {
|
|
5934
6596
|
tea_util_1.default.validateModel(request);
|
|
5935
6597
|
let query = {};
|
|
5936
|
-
|
|
5937
|
-
|
|
6598
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6599
|
+
query["DirectoryId"] = request.directoryId;
|
|
6600
|
+
}
|
|
6601
|
+
if (!tea_util_1.default.isUnset(request.MFAAuthenticationStatus)) {
|
|
6602
|
+
query["MFAAuthenticationStatus"] = request.MFAAuthenticationStatus;
|
|
6603
|
+
}
|
|
5938
6604
|
let req = new $OpenApi.OpenApiRequest({
|
|
5939
6605
|
query: openapi_util_1.default.query(query),
|
|
5940
|
-
body: tea_util_1.default.toMap(request),
|
|
5941
6606
|
});
|
|
5942
6607
|
let params = new $OpenApi.Params({
|
|
5943
6608
|
action: "SetMFAAuthenticationStatus",
|
|
@@ -5947,7 +6612,7 @@ class Client extends openapi_client_1.default {
|
|
|
5947
6612
|
method: "POST",
|
|
5948
6613
|
authType: "AK",
|
|
5949
6614
|
style: "RPC",
|
|
5950
|
-
reqBodyType: "
|
|
6615
|
+
reqBodyType: "formData",
|
|
5951
6616
|
bodyType: "json",
|
|
5952
6617
|
});
|
|
5953
6618
|
return $tea.cast(await this.callApi(params, req, runtime), new SetMFAAuthenticationStatusResponse({}));
|
|
@@ -5959,11 +6624,14 @@ class Client extends openapi_client_1.default {
|
|
|
5959
6624
|
async setSCIMSynchronizationStatusWithOptions(request, runtime) {
|
|
5960
6625
|
tea_util_1.default.validateModel(request);
|
|
5961
6626
|
let query = {};
|
|
5962
|
-
|
|
5963
|
-
|
|
6627
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6628
|
+
query["DirectoryId"] = request.directoryId;
|
|
6629
|
+
}
|
|
6630
|
+
if (!tea_util_1.default.isUnset(request.SCIMSynchronizationStatus)) {
|
|
6631
|
+
query["SCIMSynchronizationStatus"] = request.SCIMSynchronizationStatus;
|
|
6632
|
+
}
|
|
5964
6633
|
let req = new $OpenApi.OpenApiRequest({
|
|
5965
6634
|
query: openapi_util_1.default.query(query),
|
|
5966
|
-
body: tea_util_1.default.toMap(request),
|
|
5967
6635
|
});
|
|
5968
6636
|
let params = new $OpenApi.Params({
|
|
5969
6637
|
action: "SetSCIMSynchronizationStatus",
|
|
@@ -5973,7 +6641,7 @@ class Client extends openapi_client_1.default {
|
|
|
5973
6641
|
method: "POST",
|
|
5974
6642
|
authType: "AK",
|
|
5975
6643
|
style: "RPC",
|
|
5976
|
-
reqBodyType: "
|
|
6644
|
+
reqBodyType: "formData",
|
|
5977
6645
|
bodyType: "json",
|
|
5978
6646
|
});
|
|
5979
6647
|
return $tea.cast(await this.callApi(params, req, runtime), new SetSCIMSynchronizationStatusResponse({}));
|
|
@@ -5985,14 +6653,23 @@ class Client extends openapi_client_1.default {
|
|
|
5985
6653
|
async updateAccessConfigurationWithOptions(request, runtime) {
|
|
5986
6654
|
tea_util_1.default.validateModel(request);
|
|
5987
6655
|
let query = {};
|
|
5988
|
-
|
|
5989
|
-
|
|
5990
|
-
|
|
5991
|
-
|
|
5992
|
-
|
|
6656
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6657
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6658
|
+
}
|
|
6659
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6660
|
+
query["DirectoryId"] = request.directoryId;
|
|
6661
|
+
}
|
|
6662
|
+
if (!tea_util_1.default.isUnset(request.newDescription)) {
|
|
6663
|
+
query["NewDescription"] = request.newDescription;
|
|
6664
|
+
}
|
|
6665
|
+
if (!tea_util_1.default.isUnset(request.newRelayState)) {
|
|
6666
|
+
query["NewRelayState"] = request.newRelayState;
|
|
6667
|
+
}
|
|
6668
|
+
if (!tea_util_1.default.isUnset(request.newSessionDuration)) {
|
|
6669
|
+
query["NewSessionDuration"] = request.newSessionDuration;
|
|
6670
|
+
}
|
|
5993
6671
|
let req = new $OpenApi.OpenApiRequest({
|
|
5994
6672
|
query: openapi_util_1.default.query(query),
|
|
5995
|
-
body: tea_util_1.default.toMap(request),
|
|
5996
6673
|
});
|
|
5997
6674
|
let params = new $OpenApi.Params({
|
|
5998
6675
|
action: "UpdateAccessConfiguration",
|
|
@@ -6002,7 +6679,7 @@ class Client extends openapi_client_1.default {
|
|
|
6002
6679
|
method: "POST",
|
|
6003
6680
|
authType: "AK",
|
|
6004
6681
|
style: "RPC",
|
|
6005
|
-
reqBodyType: "
|
|
6682
|
+
reqBodyType: "formData",
|
|
6006
6683
|
bodyType: "json",
|
|
6007
6684
|
});
|
|
6008
6685
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateAccessConfigurationResponse({}));
|
|
@@ -6014,11 +6691,14 @@ class Client extends openapi_client_1.default {
|
|
|
6014
6691
|
async updateDirectoryWithOptions(request, runtime) {
|
|
6015
6692
|
tea_util_1.default.validateModel(request);
|
|
6016
6693
|
let query = {};
|
|
6017
|
-
|
|
6018
|
-
|
|
6694
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6695
|
+
query["DirectoryId"] = request.directoryId;
|
|
6696
|
+
}
|
|
6697
|
+
if (!tea_util_1.default.isUnset(request.newDirectoryName)) {
|
|
6698
|
+
query["NewDirectoryName"] = request.newDirectoryName;
|
|
6699
|
+
}
|
|
6019
6700
|
let req = new $OpenApi.OpenApiRequest({
|
|
6020
6701
|
query: openapi_util_1.default.query(query),
|
|
6021
|
-
body: tea_util_1.default.toMap(request),
|
|
6022
6702
|
});
|
|
6023
6703
|
let params = new $OpenApi.Params({
|
|
6024
6704
|
action: "UpdateDirectory",
|
|
@@ -6028,7 +6708,7 @@ class Client extends openapi_client_1.default {
|
|
|
6028
6708
|
method: "POST",
|
|
6029
6709
|
authType: "AK",
|
|
6030
6710
|
style: "RPC",
|
|
6031
|
-
reqBodyType: "
|
|
6711
|
+
reqBodyType: "formData",
|
|
6032
6712
|
bodyType: "json",
|
|
6033
6713
|
});
|
|
6034
6714
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateDirectoryResponse({}));
|
|
@@ -6040,13 +6720,20 @@ class Client extends openapi_client_1.default {
|
|
|
6040
6720
|
async updateGroupWithOptions(request, runtime) {
|
|
6041
6721
|
tea_util_1.default.validateModel(request);
|
|
6042
6722
|
let query = {};
|
|
6043
|
-
|
|
6044
|
-
|
|
6045
|
-
|
|
6046
|
-
|
|
6723
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6724
|
+
query["DirectoryId"] = request.directoryId;
|
|
6725
|
+
}
|
|
6726
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
6727
|
+
query["GroupId"] = request.groupId;
|
|
6728
|
+
}
|
|
6729
|
+
if (!tea_util_1.default.isUnset(request.newDescription)) {
|
|
6730
|
+
query["NewDescription"] = request.newDescription;
|
|
6731
|
+
}
|
|
6732
|
+
if (!tea_util_1.default.isUnset(request.newGroupName)) {
|
|
6733
|
+
query["NewGroupName"] = request.newGroupName;
|
|
6734
|
+
}
|
|
6047
6735
|
let req = new $OpenApi.OpenApiRequest({
|
|
6048
6736
|
query: openapi_util_1.default.query(query),
|
|
6049
|
-
body: tea_util_1.default.toMap(request),
|
|
6050
6737
|
});
|
|
6051
6738
|
let params = new $OpenApi.Params({
|
|
6052
6739
|
action: "UpdateGroup",
|
|
@@ -6056,7 +6743,7 @@ class Client extends openapi_client_1.default {
|
|
|
6056
6743
|
method: "POST",
|
|
6057
6744
|
authType: "AK",
|
|
6058
6745
|
style: "RPC",
|
|
6059
|
-
reqBodyType: "
|
|
6746
|
+
reqBodyType: "formData",
|
|
6060
6747
|
bodyType: "json",
|
|
6061
6748
|
});
|
|
6062
6749
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateGroupResponse({}));
|
|
@@ -6068,13 +6755,20 @@ class Client extends openapi_client_1.default {
|
|
|
6068
6755
|
async updateInlinePolicyForAccessConfigurationWithOptions(request, runtime) {
|
|
6069
6756
|
tea_util_1.default.validateModel(request);
|
|
6070
6757
|
let query = {};
|
|
6071
|
-
|
|
6072
|
-
|
|
6073
|
-
|
|
6074
|
-
|
|
6758
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6759
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6760
|
+
}
|
|
6761
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6762
|
+
query["DirectoryId"] = request.directoryId;
|
|
6763
|
+
}
|
|
6764
|
+
if (!tea_util_1.default.isUnset(request.inlinePolicyName)) {
|
|
6765
|
+
query["InlinePolicyName"] = request.inlinePolicyName;
|
|
6766
|
+
}
|
|
6767
|
+
if (!tea_util_1.default.isUnset(request.newInlinePolicyDocument)) {
|
|
6768
|
+
query["NewInlinePolicyDocument"] = request.newInlinePolicyDocument;
|
|
6769
|
+
}
|
|
6075
6770
|
let req = new $OpenApi.OpenApiRequest({
|
|
6076
6771
|
query: openapi_util_1.default.query(query),
|
|
6077
|
-
body: tea_util_1.default.toMap(request),
|
|
6078
6772
|
});
|
|
6079
6773
|
let params = new $OpenApi.Params({
|
|
6080
6774
|
action: "UpdateInlinePolicyForAccessConfiguration",
|
|
@@ -6084,7 +6778,7 @@ class Client extends openapi_client_1.default {
|
|
|
6084
6778
|
method: "POST",
|
|
6085
6779
|
authType: "AK",
|
|
6086
6780
|
style: "RPC",
|
|
6087
|
-
reqBodyType: "
|
|
6781
|
+
reqBodyType: "formData",
|
|
6088
6782
|
bodyType: "json",
|
|
6089
6783
|
});
|
|
6090
6784
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateInlinePolicyForAccessConfigurationResponse({}));
|
|
@@ -6093,15 +6787,49 @@ class Client extends openapi_client_1.default {
|
|
|
6093
6787
|
let runtime = new $Util.RuntimeOptions({});
|
|
6094
6788
|
return await this.updateInlinePolicyForAccessConfigurationWithOptions(request, runtime);
|
|
6095
6789
|
}
|
|
6790
|
+
async updateMFAAuthenticationSettingsWithOptions(request, runtime) {
|
|
6791
|
+
tea_util_1.default.validateModel(request);
|
|
6792
|
+
let query = {};
|
|
6793
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6794
|
+
query["DirectoryId"] = request.directoryId;
|
|
6795
|
+
}
|
|
6796
|
+
if (!tea_util_1.default.isUnset(request.MFAAuthenticationSettings)) {
|
|
6797
|
+
query["MFAAuthenticationSettings"] = request.MFAAuthenticationSettings;
|
|
6798
|
+
}
|
|
6799
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6800
|
+
query: openapi_util_1.default.query(query),
|
|
6801
|
+
});
|
|
6802
|
+
let params = new $OpenApi.Params({
|
|
6803
|
+
action: "UpdateMFAAuthenticationSettings",
|
|
6804
|
+
version: "2021-05-15",
|
|
6805
|
+
protocol: "HTTPS",
|
|
6806
|
+
pathname: "/",
|
|
6807
|
+
method: "POST",
|
|
6808
|
+
authType: "AK",
|
|
6809
|
+
style: "RPC",
|
|
6810
|
+
reqBodyType: "formData",
|
|
6811
|
+
bodyType: "json",
|
|
6812
|
+
});
|
|
6813
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateMFAAuthenticationSettingsResponse({}));
|
|
6814
|
+
}
|
|
6815
|
+
async updateMFAAuthenticationSettings(request) {
|
|
6816
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6817
|
+
return await this.updateMFAAuthenticationSettingsWithOptions(request, runtime);
|
|
6818
|
+
}
|
|
6096
6819
|
async updateSCIMServerCredentialStatusWithOptions(request, runtime) {
|
|
6097
6820
|
tea_util_1.default.validateModel(request);
|
|
6098
6821
|
let query = {};
|
|
6099
|
-
|
|
6100
|
-
|
|
6101
|
-
|
|
6822
|
+
if (!tea_util_1.default.isUnset(request.credentialId)) {
|
|
6823
|
+
query["CredentialId"] = request.credentialId;
|
|
6824
|
+
}
|
|
6825
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6826
|
+
query["DirectoryId"] = request.directoryId;
|
|
6827
|
+
}
|
|
6828
|
+
if (!tea_util_1.default.isUnset(request.newStatus)) {
|
|
6829
|
+
query["NewStatus"] = request.newStatus;
|
|
6830
|
+
}
|
|
6102
6831
|
let req = new $OpenApi.OpenApiRequest({
|
|
6103
6832
|
query: openapi_util_1.default.query(query),
|
|
6104
|
-
body: tea_util_1.default.toMap(request),
|
|
6105
6833
|
});
|
|
6106
6834
|
let params = new $OpenApi.Params({
|
|
6107
6835
|
action: "UpdateSCIMServerCredentialStatus",
|
|
@@ -6111,7 +6839,7 @@ class Client extends openapi_client_1.default {
|
|
|
6111
6839
|
method: "POST",
|
|
6112
6840
|
authType: "AK",
|
|
6113
6841
|
style: "RPC",
|
|
6114
|
-
reqBodyType: "
|
|
6842
|
+
reqBodyType: "formData",
|
|
6115
6843
|
bodyType: "json",
|
|
6116
6844
|
});
|
|
6117
6845
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateSCIMServerCredentialStatusResponse({}));
|
|
@@ -6123,16 +6851,29 @@ class Client extends openapi_client_1.default {
|
|
|
6123
6851
|
async updateUserWithOptions(request, runtime) {
|
|
6124
6852
|
tea_util_1.default.validateModel(request);
|
|
6125
6853
|
let query = {};
|
|
6126
|
-
|
|
6127
|
-
|
|
6128
|
-
|
|
6129
|
-
|
|
6130
|
-
|
|
6131
|
-
|
|
6132
|
-
|
|
6854
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6855
|
+
query["DirectoryId"] = request.directoryId;
|
|
6856
|
+
}
|
|
6857
|
+
if (!tea_util_1.default.isUnset(request.newDescription)) {
|
|
6858
|
+
query["NewDescription"] = request.newDescription;
|
|
6859
|
+
}
|
|
6860
|
+
if (!tea_util_1.default.isUnset(request.newDisplayName)) {
|
|
6861
|
+
query["NewDisplayName"] = request.newDisplayName;
|
|
6862
|
+
}
|
|
6863
|
+
if (!tea_util_1.default.isUnset(request.newEmail)) {
|
|
6864
|
+
query["NewEmail"] = request.newEmail;
|
|
6865
|
+
}
|
|
6866
|
+
if (!tea_util_1.default.isUnset(request.newFirstName)) {
|
|
6867
|
+
query["NewFirstName"] = request.newFirstName;
|
|
6868
|
+
}
|
|
6869
|
+
if (!tea_util_1.default.isUnset(request.newLastName)) {
|
|
6870
|
+
query["NewLastName"] = request.newLastName;
|
|
6871
|
+
}
|
|
6872
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6873
|
+
query["UserId"] = request.userId;
|
|
6874
|
+
}
|
|
6133
6875
|
let req = new $OpenApi.OpenApiRequest({
|
|
6134
6876
|
query: openapi_util_1.default.query(query),
|
|
6135
|
-
body: tea_util_1.default.toMap(request),
|
|
6136
6877
|
});
|
|
6137
6878
|
let params = new $OpenApi.Params({
|
|
6138
6879
|
action: "UpdateUser",
|
|
@@ -6142,7 +6883,7 @@ class Client extends openapi_client_1.default {
|
|
|
6142
6883
|
method: "POST",
|
|
6143
6884
|
authType: "AK",
|
|
6144
6885
|
style: "RPC",
|
|
6145
|
-
reqBodyType: "
|
|
6886
|
+
reqBodyType: "formData",
|
|
6146
6887
|
bodyType: "json",
|
|
6147
6888
|
});
|
|
6148
6889
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateUserResponse({}));
|
|
@@ -6151,15 +6892,52 @@ class Client extends openapi_client_1.default {
|
|
|
6151
6892
|
let runtime = new $Util.RuntimeOptions({});
|
|
6152
6893
|
return await this.updateUserWithOptions(request, runtime);
|
|
6153
6894
|
}
|
|
6895
|
+
async updateUserMFAAuthenticationSettingsWithOptions(request, runtime) {
|
|
6896
|
+
tea_util_1.default.validateModel(request);
|
|
6897
|
+
let query = {};
|
|
6898
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6899
|
+
query["DirectoryId"] = request.directoryId;
|
|
6900
|
+
}
|
|
6901
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6902
|
+
query["UserId"] = request.userId;
|
|
6903
|
+
}
|
|
6904
|
+
if (!tea_util_1.default.isUnset(request.userMFAAuthenticationSettings)) {
|
|
6905
|
+
query["UserMFAAuthenticationSettings"] = request.userMFAAuthenticationSettings;
|
|
6906
|
+
}
|
|
6907
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6908
|
+
query: openapi_util_1.default.query(query),
|
|
6909
|
+
});
|
|
6910
|
+
let params = new $OpenApi.Params({
|
|
6911
|
+
action: "UpdateUserMFAAuthenticationSettings",
|
|
6912
|
+
version: "2021-05-15",
|
|
6913
|
+
protocol: "HTTPS",
|
|
6914
|
+
pathname: "/",
|
|
6915
|
+
method: "POST",
|
|
6916
|
+
authType: "AK",
|
|
6917
|
+
style: "RPC",
|
|
6918
|
+
reqBodyType: "formData",
|
|
6919
|
+
bodyType: "json",
|
|
6920
|
+
});
|
|
6921
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateUserMFAAuthenticationSettingsResponse({}));
|
|
6922
|
+
}
|
|
6923
|
+
async updateUserMFAAuthenticationSettings(request) {
|
|
6924
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6925
|
+
return await this.updateUserMFAAuthenticationSettingsWithOptions(request, runtime);
|
|
6926
|
+
}
|
|
6154
6927
|
async updateUserStatusWithOptions(request, runtime) {
|
|
6155
6928
|
tea_util_1.default.validateModel(request);
|
|
6156
6929
|
let query = {};
|
|
6157
|
-
|
|
6158
|
-
|
|
6159
|
-
|
|
6930
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6931
|
+
query["DirectoryId"] = request.directoryId;
|
|
6932
|
+
}
|
|
6933
|
+
if (!tea_util_1.default.isUnset(request.newStatus)) {
|
|
6934
|
+
query["NewStatus"] = request.newStatus;
|
|
6935
|
+
}
|
|
6936
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6937
|
+
query["UserId"] = request.userId;
|
|
6938
|
+
}
|
|
6160
6939
|
let req = new $OpenApi.OpenApiRequest({
|
|
6161
6940
|
query: openapi_util_1.default.query(query),
|
|
6162
|
-
body: tea_util_1.default.toMap(request),
|
|
6163
6941
|
});
|
|
6164
6942
|
let params = new $OpenApi.Params({
|
|
6165
6943
|
action: "UpdateUserStatus",
|
|
@@ -6169,7 +6947,7 @@ class Client extends openapi_client_1.default {
|
|
|
6169
6947
|
method: "POST",
|
|
6170
6948
|
authType: "AK",
|
|
6171
6949
|
style: "RPC",
|
|
6172
|
-
reqBodyType: "
|
|
6950
|
+
reqBodyType: "formData",
|
|
6173
6951
|
bodyType: "json",
|
|
6174
6952
|
});
|
|
6175
6953
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateUserStatusResponse({}));
|