@alicloud/cloudsso20210515 1.0.0 → 1.0.2
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 +235 -0
- package/dist/client.js +1088 -305
- package/dist/client.js.map +1 -1
- package/package.json +4 -4
- package/src/client.ts +1413 -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,75 @@ 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
|
+
operationForRiskLogin: 'OperationForRiskLogin',
|
|
3441
|
+
};
|
|
3442
|
+
}
|
|
3443
|
+
static types() {
|
|
3444
|
+
return {
|
|
3445
|
+
directoryId: 'string',
|
|
3446
|
+
MFAAuthenticationSettings: 'string',
|
|
3447
|
+
operationForRiskLogin: 'string',
|
|
3448
|
+
};
|
|
3449
|
+
}
|
|
3450
|
+
}
|
|
3451
|
+
exports.UpdateMFAAuthenticationSettingsRequest = UpdateMFAAuthenticationSettingsRequest;
|
|
3452
|
+
class UpdateMFAAuthenticationSettingsResponseBody extends $tea.Model {
|
|
3453
|
+
constructor(map) {
|
|
3454
|
+
super(map);
|
|
3455
|
+
}
|
|
3456
|
+
static names() {
|
|
3457
|
+
return {
|
|
3458
|
+
requestId: 'RequestId',
|
|
3459
|
+
};
|
|
3460
|
+
}
|
|
3461
|
+
static types() {
|
|
3462
|
+
return {
|
|
3463
|
+
requestId: 'string',
|
|
3464
|
+
};
|
|
3465
|
+
}
|
|
3466
|
+
}
|
|
3467
|
+
exports.UpdateMFAAuthenticationSettingsResponseBody = UpdateMFAAuthenticationSettingsResponseBody;
|
|
3468
|
+
class UpdateMFAAuthenticationSettingsResponse extends $tea.Model {
|
|
3469
|
+
constructor(map) {
|
|
3470
|
+
super(map);
|
|
3471
|
+
}
|
|
3472
|
+
static names() {
|
|
3473
|
+
return {
|
|
3474
|
+
headers: 'headers',
|
|
3475
|
+
statusCode: 'statusCode',
|
|
3476
|
+
body: 'body',
|
|
3477
|
+
};
|
|
3478
|
+
}
|
|
3479
|
+
static types() {
|
|
3480
|
+
return {
|
|
3481
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3482
|
+
statusCode: 'number',
|
|
3483
|
+
body: UpdateMFAAuthenticationSettingsResponseBody,
|
|
3484
|
+
};
|
|
3485
|
+
}
|
|
3486
|
+
}
|
|
3487
|
+
exports.UpdateMFAAuthenticationSettingsResponse = UpdateMFAAuthenticationSettingsResponse;
|
|
3208
3488
|
class UpdateSCIMServerCredentialStatusRequest extends $tea.Model {
|
|
3209
3489
|
constructor(map) {
|
|
3210
3490
|
super(map);
|
|
@@ -3250,12 +3530,14 @@ class UpdateSCIMServerCredentialStatusResponse extends $tea.Model {
|
|
|
3250
3530
|
static names() {
|
|
3251
3531
|
return {
|
|
3252
3532
|
headers: 'headers',
|
|
3533
|
+
statusCode: 'statusCode',
|
|
3253
3534
|
body: 'body',
|
|
3254
3535
|
};
|
|
3255
3536
|
}
|
|
3256
3537
|
static types() {
|
|
3257
3538
|
return {
|
|
3258
3539
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3540
|
+
statusCode: 'number',
|
|
3259
3541
|
body: UpdateSCIMServerCredentialStatusResponseBody,
|
|
3260
3542
|
};
|
|
3261
3543
|
}
|
|
@@ -3314,17 +3596,75 @@ class UpdateUserResponse extends $tea.Model {
|
|
|
3314
3596
|
static names() {
|
|
3315
3597
|
return {
|
|
3316
3598
|
headers: 'headers',
|
|
3599
|
+
statusCode: 'statusCode',
|
|
3317
3600
|
body: 'body',
|
|
3318
3601
|
};
|
|
3319
3602
|
}
|
|
3320
3603
|
static types() {
|
|
3321
3604
|
return {
|
|
3322
3605
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3606
|
+
statusCode: 'number',
|
|
3323
3607
|
body: UpdateUserResponseBody,
|
|
3324
3608
|
};
|
|
3325
3609
|
}
|
|
3326
3610
|
}
|
|
3327
3611
|
exports.UpdateUserResponse = UpdateUserResponse;
|
|
3612
|
+
class UpdateUserMFAAuthenticationSettingsRequest extends $tea.Model {
|
|
3613
|
+
constructor(map) {
|
|
3614
|
+
super(map);
|
|
3615
|
+
}
|
|
3616
|
+
static names() {
|
|
3617
|
+
return {
|
|
3618
|
+
directoryId: 'DirectoryId',
|
|
3619
|
+
userId: 'UserId',
|
|
3620
|
+
userMFAAuthenticationSettings: 'UserMFAAuthenticationSettings',
|
|
3621
|
+
};
|
|
3622
|
+
}
|
|
3623
|
+
static types() {
|
|
3624
|
+
return {
|
|
3625
|
+
directoryId: 'string',
|
|
3626
|
+
userId: 'string',
|
|
3627
|
+
userMFAAuthenticationSettings: 'string',
|
|
3628
|
+
};
|
|
3629
|
+
}
|
|
3630
|
+
}
|
|
3631
|
+
exports.UpdateUserMFAAuthenticationSettingsRequest = UpdateUserMFAAuthenticationSettingsRequest;
|
|
3632
|
+
class UpdateUserMFAAuthenticationSettingsResponseBody extends $tea.Model {
|
|
3633
|
+
constructor(map) {
|
|
3634
|
+
super(map);
|
|
3635
|
+
}
|
|
3636
|
+
static names() {
|
|
3637
|
+
return {
|
|
3638
|
+
requestId: 'RequestId',
|
|
3639
|
+
};
|
|
3640
|
+
}
|
|
3641
|
+
static types() {
|
|
3642
|
+
return {
|
|
3643
|
+
requestId: 'string',
|
|
3644
|
+
};
|
|
3645
|
+
}
|
|
3646
|
+
}
|
|
3647
|
+
exports.UpdateUserMFAAuthenticationSettingsResponseBody = UpdateUserMFAAuthenticationSettingsResponseBody;
|
|
3648
|
+
class UpdateUserMFAAuthenticationSettingsResponse extends $tea.Model {
|
|
3649
|
+
constructor(map) {
|
|
3650
|
+
super(map);
|
|
3651
|
+
}
|
|
3652
|
+
static names() {
|
|
3653
|
+
return {
|
|
3654
|
+
headers: 'headers',
|
|
3655
|
+
statusCode: 'statusCode',
|
|
3656
|
+
body: 'body',
|
|
3657
|
+
};
|
|
3658
|
+
}
|
|
3659
|
+
static types() {
|
|
3660
|
+
return {
|
|
3661
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3662
|
+
statusCode: 'number',
|
|
3663
|
+
body: UpdateUserMFAAuthenticationSettingsResponseBody,
|
|
3664
|
+
};
|
|
3665
|
+
}
|
|
3666
|
+
}
|
|
3667
|
+
exports.UpdateUserMFAAuthenticationSettingsResponse = UpdateUserMFAAuthenticationSettingsResponse;
|
|
3328
3668
|
class UpdateUserStatusRequest extends $tea.Model {
|
|
3329
3669
|
constructor(map) {
|
|
3330
3670
|
super(map);
|
|
@@ -3368,12 +3708,14 @@ class UpdateUserStatusResponse extends $tea.Model {
|
|
|
3368
3708
|
static names() {
|
|
3369
3709
|
return {
|
|
3370
3710
|
headers: 'headers',
|
|
3711
|
+
statusCode: 'statusCode',
|
|
3371
3712
|
body: 'body',
|
|
3372
3713
|
};
|
|
3373
3714
|
}
|
|
3374
3715
|
static types() {
|
|
3375
3716
|
return {
|
|
3376
3717
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3718
|
+
statusCode: 'number',
|
|
3377
3719
|
body: UpdateUserStatusResponseBody,
|
|
3378
3720
|
};
|
|
3379
3721
|
}
|
|
@@ -4572,11 +4914,14 @@ class Client extends openapi_client_1.default {
|
|
|
4572
4914
|
async addExternalSAMLIdPCertificateWithOptions(request, runtime) {
|
|
4573
4915
|
tea_util_1.default.validateModel(request);
|
|
4574
4916
|
let query = {};
|
|
4575
|
-
|
|
4576
|
-
|
|
4917
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
4918
|
+
query["DirectoryId"] = request.directoryId;
|
|
4919
|
+
}
|
|
4920
|
+
if (!tea_util_1.default.isUnset(request.x509Certificate)) {
|
|
4921
|
+
query["X509Certificate"] = request.x509Certificate;
|
|
4922
|
+
}
|
|
4577
4923
|
let req = new $OpenApi.OpenApiRequest({
|
|
4578
4924
|
query: openapi_util_1.default.query(query),
|
|
4579
|
-
body: tea_util_1.default.toMap(request),
|
|
4580
4925
|
});
|
|
4581
4926
|
let params = new $OpenApi.Params({
|
|
4582
4927
|
action: "AddExternalSAMLIdPCertificate",
|
|
@@ -4586,7 +4931,7 @@ class Client extends openapi_client_1.default {
|
|
|
4586
4931
|
method: "POST",
|
|
4587
4932
|
authType: "AK",
|
|
4588
4933
|
style: "RPC",
|
|
4589
|
-
reqBodyType: "
|
|
4934
|
+
reqBodyType: "formData",
|
|
4590
4935
|
bodyType: "json",
|
|
4591
4936
|
});
|
|
4592
4937
|
return $tea.cast(await this.callApi(params, req, runtime), new AddExternalSAMLIdPCertificateResponse({}));
|
|
@@ -4598,14 +4943,23 @@ class Client extends openapi_client_1.default {
|
|
|
4598
4943
|
async addPermissionPolicyToAccessConfigurationWithOptions(request, runtime) {
|
|
4599
4944
|
tea_util_1.default.validateModel(request);
|
|
4600
4945
|
let query = {};
|
|
4601
|
-
|
|
4602
|
-
|
|
4603
|
-
|
|
4604
|
-
|
|
4605
|
-
|
|
4946
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
4947
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
4948
|
+
}
|
|
4949
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
4950
|
+
query["DirectoryId"] = request.directoryId;
|
|
4951
|
+
}
|
|
4952
|
+
if (!tea_util_1.default.isUnset(request.inlinePolicyDocument)) {
|
|
4953
|
+
query["InlinePolicyDocument"] = request.inlinePolicyDocument;
|
|
4954
|
+
}
|
|
4955
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyName)) {
|
|
4956
|
+
query["PermissionPolicyName"] = request.permissionPolicyName;
|
|
4957
|
+
}
|
|
4958
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyType)) {
|
|
4959
|
+
query["PermissionPolicyType"] = request.permissionPolicyType;
|
|
4960
|
+
}
|
|
4606
4961
|
let req = new $OpenApi.OpenApiRequest({
|
|
4607
4962
|
query: openapi_util_1.default.query(query),
|
|
4608
|
-
body: tea_util_1.default.toMap(request),
|
|
4609
4963
|
});
|
|
4610
4964
|
let params = new $OpenApi.Params({
|
|
4611
4965
|
action: "AddPermissionPolicyToAccessConfiguration",
|
|
@@ -4615,7 +4969,7 @@ class Client extends openapi_client_1.default {
|
|
|
4615
4969
|
method: "POST",
|
|
4616
4970
|
authType: "AK",
|
|
4617
4971
|
style: "RPC",
|
|
4618
|
-
reqBodyType: "
|
|
4972
|
+
reqBodyType: "formData",
|
|
4619
4973
|
bodyType: "json",
|
|
4620
4974
|
});
|
|
4621
4975
|
return $tea.cast(await this.callApi(params, req, runtime), new AddPermissionPolicyToAccessConfigurationResponse({}));
|
|
@@ -4627,12 +4981,17 @@ class Client extends openapi_client_1.default {
|
|
|
4627
4981
|
async addUserToGroupWithOptions(request, runtime) {
|
|
4628
4982
|
tea_util_1.default.validateModel(request);
|
|
4629
4983
|
let query = {};
|
|
4630
|
-
|
|
4631
|
-
|
|
4632
|
-
|
|
4984
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
4985
|
+
query["DirectoryId"] = request.directoryId;
|
|
4986
|
+
}
|
|
4987
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
4988
|
+
query["GroupId"] = request.groupId;
|
|
4989
|
+
}
|
|
4990
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
4991
|
+
query["UserId"] = request.userId;
|
|
4992
|
+
}
|
|
4633
4993
|
let req = new $OpenApi.OpenApiRequest({
|
|
4634
4994
|
query: openapi_util_1.default.query(query),
|
|
4635
|
-
body: tea_util_1.default.toMap(request),
|
|
4636
4995
|
});
|
|
4637
4996
|
let params = new $OpenApi.Params({
|
|
4638
4997
|
action: "AddUserToGroup",
|
|
@@ -4642,7 +5001,7 @@ class Client extends openapi_client_1.default {
|
|
|
4642
5001
|
method: "POST",
|
|
4643
5002
|
authType: "AK",
|
|
4644
5003
|
style: "RPC",
|
|
4645
|
-
reqBodyType: "
|
|
5004
|
+
reqBodyType: "formData",
|
|
4646
5005
|
bodyType: "json",
|
|
4647
5006
|
});
|
|
4648
5007
|
return $tea.cast(await this.callApi(params, req, runtime), new AddUserToGroupResponse({}));
|
|
@@ -4654,10 +5013,11 @@ class Client extends openapi_client_1.default {
|
|
|
4654
5013
|
async clearExternalSAMLIdentityProviderWithOptions(request, runtime) {
|
|
4655
5014
|
tea_util_1.default.validateModel(request);
|
|
4656
5015
|
let query = {};
|
|
4657
|
-
|
|
5016
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5017
|
+
query["DirectoryId"] = request.directoryId;
|
|
5018
|
+
}
|
|
4658
5019
|
let req = new $OpenApi.OpenApiRequest({
|
|
4659
5020
|
query: openapi_util_1.default.query(query),
|
|
4660
|
-
body: tea_util_1.default.toMap(request),
|
|
4661
5021
|
});
|
|
4662
5022
|
let params = new $OpenApi.Params({
|
|
4663
5023
|
action: "ClearExternalSAMLIdentityProvider",
|
|
@@ -4667,7 +5027,7 @@ class Client extends openapi_client_1.default {
|
|
|
4667
5027
|
method: "POST",
|
|
4668
5028
|
authType: "AK",
|
|
4669
5029
|
style: "RPC",
|
|
4670
|
-
reqBodyType: "
|
|
5030
|
+
reqBodyType: "formData",
|
|
4671
5031
|
bodyType: "json",
|
|
4672
5032
|
});
|
|
4673
5033
|
return $tea.cast(await this.callApi(params, req, runtime), new ClearExternalSAMLIdentityProviderResponse({}));
|
|
@@ -4679,15 +5039,26 @@ class Client extends openapi_client_1.default {
|
|
|
4679
5039
|
async createAccessAssignmentWithOptions(request, runtime) {
|
|
4680
5040
|
tea_util_1.default.validateModel(request);
|
|
4681
5041
|
let query = {};
|
|
4682
|
-
|
|
4683
|
-
|
|
4684
|
-
|
|
4685
|
-
|
|
4686
|
-
|
|
4687
|
-
|
|
5042
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5043
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5044
|
+
}
|
|
5045
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5046
|
+
query["DirectoryId"] = request.directoryId;
|
|
5047
|
+
}
|
|
5048
|
+
if (!tea_util_1.default.isUnset(request.principalId)) {
|
|
5049
|
+
query["PrincipalId"] = request.principalId;
|
|
5050
|
+
}
|
|
5051
|
+
if (!tea_util_1.default.isUnset(request.principalType)) {
|
|
5052
|
+
query["PrincipalType"] = request.principalType;
|
|
5053
|
+
}
|
|
5054
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5055
|
+
query["TargetId"] = request.targetId;
|
|
5056
|
+
}
|
|
5057
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5058
|
+
query["TargetType"] = request.targetType;
|
|
5059
|
+
}
|
|
4688
5060
|
let req = new $OpenApi.OpenApiRequest({
|
|
4689
5061
|
query: openapi_util_1.default.query(query),
|
|
4690
|
-
body: tea_util_1.default.toMap(request),
|
|
4691
5062
|
});
|
|
4692
5063
|
let params = new $OpenApi.Params({
|
|
4693
5064
|
action: "CreateAccessAssignment",
|
|
@@ -4697,7 +5068,7 @@ class Client extends openapi_client_1.default {
|
|
|
4697
5068
|
method: "POST",
|
|
4698
5069
|
authType: "AK",
|
|
4699
5070
|
style: "RPC",
|
|
4700
|
-
reqBodyType: "
|
|
5071
|
+
reqBodyType: "formData",
|
|
4701
5072
|
bodyType: "json",
|
|
4702
5073
|
});
|
|
4703
5074
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateAccessAssignmentResponse({}));
|
|
@@ -4709,14 +5080,23 @@ class Client extends openapi_client_1.default {
|
|
|
4709
5080
|
async createAccessConfigurationWithOptions(request, runtime) {
|
|
4710
5081
|
tea_util_1.default.validateModel(request);
|
|
4711
5082
|
let query = {};
|
|
4712
|
-
|
|
4713
|
-
|
|
4714
|
-
|
|
4715
|
-
|
|
4716
|
-
|
|
5083
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationName)) {
|
|
5084
|
+
query["AccessConfigurationName"] = request.accessConfigurationName;
|
|
5085
|
+
}
|
|
5086
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
5087
|
+
query["Description"] = request.description;
|
|
5088
|
+
}
|
|
5089
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5090
|
+
query["DirectoryId"] = request.directoryId;
|
|
5091
|
+
}
|
|
5092
|
+
if (!tea_util_1.default.isUnset(request.relayState)) {
|
|
5093
|
+
query["RelayState"] = request.relayState;
|
|
5094
|
+
}
|
|
5095
|
+
if (!tea_util_1.default.isUnset(request.sessionDuration)) {
|
|
5096
|
+
query["SessionDuration"] = request.sessionDuration;
|
|
5097
|
+
}
|
|
4717
5098
|
let req = new $OpenApi.OpenApiRequest({
|
|
4718
5099
|
query: openapi_util_1.default.query(query),
|
|
4719
|
-
body: tea_util_1.default.toMap(request),
|
|
4720
5100
|
});
|
|
4721
5101
|
let params = new $OpenApi.Params({
|
|
4722
5102
|
action: "CreateAccessConfiguration",
|
|
@@ -4726,7 +5106,7 @@ class Client extends openapi_client_1.default {
|
|
|
4726
5106
|
method: "POST",
|
|
4727
5107
|
authType: "AK",
|
|
4728
5108
|
style: "RPC",
|
|
4729
|
-
reqBodyType: "
|
|
5109
|
+
reqBodyType: "formData",
|
|
4730
5110
|
bodyType: "json",
|
|
4731
5111
|
});
|
|
4732
5112
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateAccessConfigurationResponse({}));
|
|
@@ -4738,10 +5118,11 @@ class Client extends openapi_client_1.default {
|
|
|
4738
5118
|
async createDirectoryWithOptions(request, runtime) {
|
|
4739
5119
|
tea_util_1.default.validateModel(request);
|
|
4740
5120
|
let query = {};
|
|
4741
|
-
|
|
5121
|
+
if (!tea_util_1.default.isUnset(request.directoryName)) {
|
|
5122
|
+
query["DirectoryName"] = request.directoryName;
|
|
5123
|
+
}
|
|
4742
5124
|
let req = new $OpenApi.OpenApiRequest({
|
|
4743
5125
|
query: openapi_util_1.default.query(query),
|
|
4744
|
-
body: tea_util_1.default.toMap(request),
|
|
4745
5126
|
});
|
|
4746
5127
|
let params = new $OpenApi.Params({
|
|
4747
5128
|
action: "CreateDirectory",
|
|
@@ -4751,7 +5132,7 @@ class Client extends openapi_client_1.default {
|
|
|
4751
5132
|
method: "POST",
|
|
4752
5133
|
authType: "AK",
|
|
4753
5134
|
style: "RPC",
|
|
4754
|
-
reqBodyType: "
|
|
5135
|
+
reqBodyType: "formData",
|
|
4755
5136
|
bodyType: "json",
|
|
4756
5137
|
});
|
|
4757
5138
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateDirectoryResponse({}));
|
|
@@ -4763,12 +5144,17 @@ class Client extends openapi_client_1.default {
|
|
|
4763
5144
|
async createGroupWithOptions(request, runtime) {
|
|
4764
5145
|
tea_util_1.default.validateModel(request);
|
|
4765
5146
|
let query = {};
|
|
4766
|
-
|
|
4767
|
-
|
|
4768
|
-
|
|
5147
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
5148
|
+
query["Description"] = request.description;
|
|
5149
|
+
}
|
|
5150
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5151
|
+
query["DirectoryId"] = request.directoryId;
|
|
5152
|
+
}
|
|
5153
|
+
if (!tea_util_1.default.isUnset(request.groupName)) {
|
|
5154
|
+
query["GroupName"] = request.groupName;
|
|
5155
|
+
}
|
|
4769
5156
|
let req = new $OpenApi.OpenApiRequest({
|
|
4770
5157
|
query: openapi_util_1.default.query(query),
|
|
4771
|
-
body: tea_util_1.default.toMap(request),
|
|
4772
5158
|
});
|
|
4773
5159
|
let params = new $OpenApi.Params({
|
|
4774
5160
|
action: "CreateGroup",
|
|
@@ -4778,7 +5164,7 @@ class Client extends openapi_client_1.default {
|
|
|
4778
5164
|
method: "POST",
|
|
4779
5165
|
authType: "AK",
|
|
4780
5166
|
style: "RPC",
|
|
4781
|
-
reqBodyType: "
|
|
5167
|
+
reqBodyType: "formData",
|
|
4782
5168
|
bodyType: "json",
|
|
4783
5169
|
});
|
|
4784
5170
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateGroupResponse({}));
|
|
@@ -4790,10 +5176,11 @@ class Client extends openapi_client_1.default {
|
|
|
4790
5176
|
async createSCIMServerCredentialWithOptions(request, runtime) {
|
|
4791
5177
|
tea_util_1.default.validateModel(request);
|
|
4792
5178
|
let query = {};
|
|
4793
|
-
|
|
5179
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5180
|
+
query["DirectoryId"] = request.directoryId;
|
|
5181
|
+
}
|
|
4794
5182
|
let req = new $OpenApi.OpenApiRequest({
|
|
4795
5183
|
query: openapi_util_1.default.query(query),
|
|
4796
|
-
body: tea_util_1.default.toMap(request),
|
|
4797
5184
|
});
|
|
4798
5185
|
let params = new $OpenApi.Params({
|
|
4799
5186
|
action: "CreateSCIMServerCredential",
|
|
@@ -4803,7 +5190,7 @@ class Client extends openapi_client_1.default {
|
|
|
4803
5190
|
method: "POST",
|
|
4804
5191
|
authType: "AK",
|
|
4805
5192
|
style: "RPC",
|
|
4806
|
-
reqBodyType: "
|
|
5193
|
+
reqBodyType: "formData",
|
|
4807
5194
|
bodyType: "json",
|
|
4808
5195
|
});
|
|
4809
5196
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateSCIMServerCredentialResponse({}));
|
|
@@ -4815,17 +5202,32 @@ class Client extends openapi_client_1.default {
|
|
|
4815
5202
|
async createUserWithOptions(request, runtime) {
|
|
4816
5203
|
tea_util_1.default.validateModel(request);
|
|
4817
5204
|
let query = {};
|
|
4818
|
-
|
|
4819
|
-
|
|
4820
|
-
|
|
4821
|
-
|
|
4822
|
-
|
|
4823
|
-
|
|
4824
|
-
|
|
4825
|
-
|
|
5205
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
5206
|
+
query["Description"] = request.description;
|
|
5207
|
+
}
|
|
5208
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5209
|
+
query["DirectoryId"] = request.directoryId;
|
|
5210
|
+
}
|
|
5211
|
+
if (!tea_util_1.default.isUnset(request.displayName)) {
|
|
5212
|
+
query["DisplayName"] = request.displayName;
|
|
5213
|
+
}
|
|
5214
|
+
if (!tea_util_1.default.isUnset(request.email)) {
|
|
5215
|
+
query["Email"] = request.email;
|
|
5216
|
+
}
|
|
5217
|
+
if (!tea_util_1.default.isUnset(request.firstName)) {
|
|
5218
|
+
query["FirstName"] = request.firstName;
|
|
5219
|
+
}
|
|
5220
|
+
if (!tea_util_1.default.isUnset(request.lastName)) {
|
|
5221
|
+
query["LastName"] = request.lastName;
|
|
5222
|
+
}
|
|
5223
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
5224
|
+
query["Status"] = request.status;
|
|
5225
|
+
}
|
|
5226
|
+
if (!tea_util_1.default.isUnset(request.userName)) {
|
|
5227
|
+
query["UserName"] = request.userName;
|
|
5228
|
+
}
|
|
4826
5229
|
let req = new $OpenApi.OpenApiRequest({
|
|
4827
5230
|
query: openapi_util_1.default.query(query),
|
|
4828
|
-
body: tea_util_1.default.toMap(request),
|
|
4829
5231
|
});
|
|
4830
5232
|
let params = new $OpenApi.Params({
|
|
4831
5233
|
action: "CreateUser",
|
|
@@ -4835,7 +5237,7 @@ class Client extends openapi_client_1.default {
|
|
|
4835
5237
|
method: "POST",
|
|
4836
5238
|
authType: "AK",
|
|
4837
5239
|
style: "RPC",
|
|
4838
|
-
reqBodyType: "
|
|
5240
|
+
reqBodyType: "formData",
|
|
4839
5241
|
bodyType: "json",
|
|
4840
5242
|
});
|
|
4841
5243
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateUserResponse({}));
|
|
@@ -4847,16 +5249,29 @@ class Client extends openapi_client_1.default {
|
|
|
4847
5249
|
async deleteAccessAssignmentWithOptions(request, runtime) {
|
|
4848
5250
|
tea_util_1.default.validateModel(request);
|
|
4849
5251
|
let query = {};
|
|
4850
|
-
|
|
4851
|
-
|
|
4852
|
-
|
|
4853
|
-
|
|
4854
|
-
|
|
4855
|
-
|
|
4856
|
-
|
|
5252
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5253
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5254
|
+
}
|
|
5255
|
+
if (!tea_util_1.default.isUnset(request.deprovisionStrategy)) {
|
|
5256
|
+
query["DeprovisionStrategy"] = request.deprovisionStrategy;
|
|
5257
|
+
}
|
|
5258
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5259
|
+
query["DirectoryId"] = request.directoryId;
|
|
5260
|
+
}
|
|
5261
|
+
if (!tea_util_1.default.isUnset(request.principalId)) {
|
|
5262
|
+
query["PrincipalId"] = request.principalId;
|
|
5263
|
+
}
|
|
5264
|
+
if (!tea_util_1.default.isUnset(request.principalType)) {
|
|
5265
|
+
query["PrincipalType"] = request.principalType;
|
|
5266
|
+
}
|
|
5267
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5268
|
+
query["TargetId"] = request.targetId;
|
|
5269
|
+
}
|
|
5270
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5271
|
+
query["TargetType"] = request.targetType;
|
|
5272
|
+
}
|
|
4857
5273
|
let req = new $OpenApi.OpenApiRequest({
|
|
4858
5274
|
query: openapi_util_1.default.query(query),
|
|
4859
|
-
body: tea_util_1.default.toMap(request),
|
|
4860
5275
|
});
|
|
4861
5276
|
let params = new $OpenApi.Params({
|
|
4862
5277
|
action: "DeleteAccessAssignment",
|
|
@@ -4866,7 +5281,7 @@ class Client extends openapi_client_1.default {
|
|
|
4866
5281
|
method: "POST",
|
|
4867
5282
|
authType: "AK",
|
|
4868
5283
|
style: "RPC",
|
|
4869
|
-
reqBodyType: "
|
|
5284
|
+
reqBodyType: "formData",
|
|
4870
5285
|
bodyType: "json",
|
|
4871
5286
|
});
|
|
4872
5287
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteAccessAssignmentResponse({}));
|
|
@@ -4878,12 +5293,17 @@ class Client extends openapi_client_1.default {
|
|
|
4878
5293
|
async deleteAccessConfigurationWithOptions(request, runtime) {
|
|
4879
5294
|
tea_util_1.default.validateModel(request);
|
|
4880
5295
|
let query = {};
|
|
4881
|
-
|
|
4882
|
-
|
|
4883
|
-
|
|
5296
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5297
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5298
|
+
}
|
|
5299
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5300
|
+
query["DirectoryId"] = request.directoryId;
|
|
5301
|
+
}
|
|
5302
|
+
if (!tea_util_1.default.isUnset(request.forceRemovePermissionPolicies)) {
|
|
5303
|
+
query["ForceRemovePermissionPolicies"] = request.forceRemovePermissionPolicies;
|
|
5304
|
+
}
|
|
4884
5305
|
let req = new $OpenApi.OpenApiRequest({
|
|
4885
5306
|
query: openapi_util_1.default.query(query),
|
|
4886
|
-
body: tea_util_1.default.toMap(request),
|
|
4887
5307
|
});
|
|
4888
5308
|
let params = new $OpenApi.Params({
|
|
4889
5309
|
action: "DeleteAccessConfiguration",
|
|
@@ -4893,7 +5313,7 @@ class Client extends openapi_client_1.default {
|
|
|
4893
5313
|
method: "POST",
|
|
4894
5314
|
authType: "AK",
|
|
4895
5315
|
style: "RPC",
|
|
4896
|
-
reqBodyType: "
|
|
5316
|
+
reqBodyType: "formData",
|
|
4897
5317
|
bodyType: "json",
|
|
4898
5318
|
});
|
|
4899
5319
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteAccessConfigurationResponse({}));
|
|
@@ -4905,10 +5325,11 @@ class Client extends openapi_client_1.default {
|
|
|
4905
5325
|
async deleteDirectoryWithOptions(request, runtime) {
|
|
4906
5326
|
tea_util_1.default.validateModel(request);
|
|
4907
5327
|
let query = {};
|
|
4908
|
-
|
|
5328
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5329
|
+
query["DirectoryId"] = request.directoryId;
|
|
5330
|
+
}
|
|
4909
5331
|
let req = new $OpenApi.OpenApiRequest({
|
|
4910
5332
|
query: openapi_util_1.default.query(query),
|
|
4911
|
-
body: tea_util_1.default.toMap(request),
|
|
4912
5333
|
});
|
|
4913
5334
|
let params = new $OpenApi.Params({
|
|
4914
5335
|
action: "DeleteDirectory",
|
|
@@ -4918,7 +5339,7 @@ class Client extends openapi_client_1.default {
|
|
|
4918
5339
|
method: "POST",
|
|
4919
5340
|
authType: "AK",
|
|
4920
5341
|
style: "RPC",
|
|
4921
|
-
reqBodyType: "
|
|
5342
|
+
reqBodyType: "formData",
|
|
4922
5343
|
bodyType: "json",
|
|
4923
5344
|
});
|
|
4924
5345
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteDirectoryResponse({}));
|
|
@@ -4930,11 +5351,14 @@ class Client extends openapi_client_1.default {
|
|
|
4930
5351
|
async deleteGroupWithOptions(request, runtime) {
|
|
4931
5352
|
tea_util_1.default.validateModel(request);
|
|
4932
5353
|
let query = {};
|
|
4933
|
-
|
|
4934
|
-
|
|
5354
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5355
|
+
query["DirectoryId"] = request.directoryId;
|
|
5356
|
+
}
|
|
5357
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
5358
|
+
query["GroupId"] = request.groupId;
|
|
5359
|
+
}
|
|
4935
5360
|
let req = new $OpenApi.OpenApiRequest({
|
|
4936
5361
|
query: openapi_util_1.default.query(query),
|
|
4937
|
-
body: tea_util_1.default.toMap(request),
|
|
4938
5362
|
});
|
|
4939
5363
|
let params = new $OpenApi.Params({
|
|
4940
5364
|
action: "DeleteGroup",
|
|
@@ -4944,7 +5368,7 @@ class Client extends openapi_client_1.default {
|
|
|
4944
5368
|
method: "POST",
|
|
4945
5369
|
authType: "AK",
|
|
4946
5370
|
style: "RPC",
|
|
4947
|
-
reqBodyType: "
|
|
5371
|
+
reqBodyType: "formData",
|
|
4948
5372
|
bodyType: "json",
|
|
4949
5373
|
});
|
|
4950
5374
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteGroupResponse({}));
|
|
@@ -4956,12 +5380,17 @@ class Client extends openapi_client_1.default {
|
|
|
4956
5380
|
async deleteMFADeviceForUserWithOptions(request, runtime) {
|
|
4957
5381
|
tea_util_1.default.validateModel(request);
|
|
4958
5382
|
let query = {};
|
|
4959
|
-
|
|
4960
|
-
|
|
4961
|
-
|
|
5383
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5384
|
+
query["DirectoryId"] = request.directoryId;
|
|
5385
|
+
}
|
|
5386
|
+
if (!tea_util_1.default.isUnset(request.MFADeviceId)) {
|
|
5387
|
+
query["MFADeviceId"] = request.MFADeviceId;
|
|
5388
|
+
}
|
|
5389
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
5390
|
+
query["UserId"] = request.userId;
|
|
5391
|
+
}
|
|
4962
5392
|
let req = new $OpenApi.OpenApiRequest({
|
|
4963
5393
|
query: openapi_util_1.default.query(query),
|
|
4964
|
-
body: tea_util_1.default.toMap(request),
|
|
4965
5394
|
});
|
|
4966
5395
|
let params = new $OpenApi.Params({
|
|
4967
5396
|
action: "DeleteMFADeviceForUser",
|
|
@@ -4971,7 +5400,7 @@ class Client extends openapi_client_1.default {
|
|
|
4971
5400
|
method: "POST",
|
|
4972
5401
|
authType: "AK",
|
|
4973
5402
|
style: "RPC",
|
|
4974
|
-
reqBodyType: "
|
|
5403
|
+
reqBodyType: "formData",
|
|
4975
5404
|
bodyType: "json",
|
|
4976
5405
|
});
|
|
4977
5406
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteMFADeviceForUserResponse({}));
|
|
@@ -4983,11 +5412,14 @@ class Client extends openapi_client_1.default {
|
|
|
4983
5412
|
async deleteSCIMServerCredentialWithOptions(request, runtime) {
|
|
4984
5413
|
tea_util_1.default.validateModel(request);
|
|
4985
5414
|
let query = {};
|
|
4986
|
-
|
|
4987
|
-
|
|
5415
|
+
if (!tea_util_1.default.isUnset(request.credentialId)) {
|
|
5416
|
+
query["CredentialId"] = request.credentialId;
|
|
5417
|
+
}
|
|
5418
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5419
|
+
query["DirectoryId"] = request.directoryId;
|
|
5420
|
+
}
|
|
4988
5421
|
let req = new $OpenApi.OpenApiRequest({
|
|
4989
5422
|
query: openapi_util_1.default.query(query),
|
|
4990
|
-
body: tea_util_1.default.toMap(request),
|
|
4991
5423
|
});
|
|
4992
5424
|
let params = new $OpenApi.Params({
|
|
4993
5425
|
action: "DeleteSCIMServerCredential",
|
|
@@ -4997,7 +5429,7 @@ class Client extends openapi_client_1.default {
|
|
|
4997
5429
|
method: "POST",
|
|
4998
5430
|
authType: "AK",
|
|
4999
5431
|
style: "RPC",
|
|
5000
|
-
reqBodyType: "
|
|
5432
|
+
reqBodyType: "formData",
|
|
5001
5433
|
bodyType: "json",
|
|
5002
5434
|
});
|
|
5003
5435
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteSCIMServerCredentialResponse({}));
|
|
@@ -5009,11 +5441,14 @@ class Client extends openapi_client_1.default {
|
|
|
5009
5441
|
async deleteUserWithOptions(request, runtime) {
|
|
5010
5442
|
tea_util_1.default.validateModel(request);
|
|
5011
5443
|
let query = {};
|
|
5012
|
-
|
|
5013
|
-
|
|
5444
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5445
|
+
query["DirectoryId"] = request.directoryId;
|
|
5446
|
+
}
|
|
5447
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
5448
|
+
query["UserId"] = request.userId;
|
|
5449
|
+
}
|
|
5014
5450
|
let req = new $OpenApi.OpenApiRequest({
|
|
5015
5451
|
query: openapi_util_1.default.query(query),
|
|
5016
|
-
body: tea_util_1.default.toMap(request),
|
|
5017
5452
|
});
|
|
5018
5453
|
let params = new $OpenApi.Params({
|
|
5019
5454
|
action: "DeleteUser",
|
|
@@ -5023,7 +5458,7 @@ class Client extends openapi_client_1.default {
|
|
|
5023
5458
|
method: "POST",
|
|
5024
5459
|
authType: "AK",
|
|
5025
5460
|
style: "RPC",
|
|
5026
|
-
reqBodyType: "
|
|
5461
|
+
reqBodyType: "formData",
|
|
5027
5462
|
bodyType: "json",
|
|
5028
5463
|
});
|
|
5029
5464
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteUserResponse({}));
|
|
@@ -5035,13 +5470,20 @@ class Client extends openapi_client_1.default {
|
|
|
5035
5470
|
async deprovisionAccessConfigurationWithOptions(request, runtime) {
|
|
5036
5471
|
tea_util_1.default.validateModel(request);
|
|
5037
5472
|
let query = {};
|
|
5038
|
-
|
|
5039
|
-
|
|
5040
|
-
|
|
5041
|
-
|
|
5473
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5474
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5475
|
+
}
|
|
5476
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5477
|
+
query["DirectoryId"] = request.directoryId;
|
|
5478
|
+
}
|
|
5479
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5480
|
+
query["TargetId"] = request.targetId;
|
|
5481
|
+
}
|
|
5482
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5483
|
+
query["TargetType"] = request.targetType;
|
|
5484
|
+
}
|
|
5042
5485
|
let req = new $OpenApi.OpenApiRequest({
|
|
5043
5486
|
query: openapi_util_1.default.query(query),
|
|
5044
|
-
body: tea_util_1.default.toMap(request),
|
|
5045
5487
|
});
|
|
5046
5488
|
let params = new $OpenApi.Params({
|
|
5047
5489
|
action: "DeprovisionAccessConfiguration",
|
|
@@ -5051,7 +5493,7 @@ class Client extends openapi_client_1.default {
|
|
|
5051
5493
|
method: "POST",
|
|
5052
5494
|
authType: "AK",
|
|
5053
5495
|
style: "RPC",
|
|
5054
|
-
reqBodyType: "
|
|
5496
|
+
reqBodyType: "formData",
|
|
5055
5497
|
bodyType: "json",
|
|
5056
5498
|
});
|
|
5057
5499
|
return $tea.cast(await this.callApi(params, req, runtime), new DeprovisionAccessConfigurationResponse({}));
|
|
@@ -5070,7 +5512,7 @@ class Client extends openapi_client_1.default {
|
|
|
5070
5512
|
method: "POST",
|
|
5071
5513
|
authType: "AK",
|
|
5072
5514
|
style: "RPC",
|
|
5073
|
-
reqBodyType: "
|
|
5515
|
+
reqBodyType: "formData",
|
|
5074
5516
|
bodyType: "json",
|
|
5075
5517
|
});
|
|
5076
5518
|
return $tea.cast(await this.callApi(params, req, runtime), new DisableServiceResponse({}));
|
|
@@ -5089,7 +5531,7 @@ class Client extends openapi_client_1.default {
|
|
|
5089
5531
|
method: "POST",
|
|
5090
5532
|
authType: "AK",
|
|
5091
5533
|
style: "RPC",
|
|
5092
|
-
reqBodyType: "
|
|
5534
|
+
reqBodyType: "formData",
|
|
5093
5535
|
bodyType: "json",
|
|
5094
5536
|
});
|
|
5095
5537
|
return $tea.cast(await this.callApi(params, req, runtime), new EnableServiceResponse({}));
|
|
@@ -5101,11 +5543,14 @@ class Client extends openapi_client_1.default {
|
|
|
5101
5543
|
async getAccessConfigurationWithOptions(request, runtime) {
|
|
5102
5544
|
tea_util_1.default.validateModel(request);
|
|
5103
5545
|
let query = {};
|
|
5104
|
-
|
|
5105
|
-
|
|
5546
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5547
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5548
|
+
}
|
|
5549
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5550
|
+
query["DirectoryId"] = request.directoryId;
|
|
5551
|
+
}
|
|
5106
5552
|
let req = new $OpenApi.OpenApiRequest({
|
|
5107
5553
|
query: openapi_util_1.default.query(query),
|
|
5108
|
-
body: tea_util_1.default.toMap(request),
|
|
5109
5554
|
});
|
|
5110
5555
|
let params = new $OpenApi.Params({
|
|
5111
5556
|
action: "GetAccessConfiguration",
|
|
@@ -5115,7 +5560,7 @@ class Client extends openapi_client_1.default {
|
|
|
5115
5560
|
method: "POST",
|
|
5116
5561
|
authType: "AK",
|
|
5117
5562
|
style: "RPC",
|
|
5118
|
-
reqBodyType: "
|
|
5563
|
+
reqBodyType: "formData",
|
|
5119
5564
|
bodyType: "json",
|
|
5120
5565
|
});
|
|
5121
5566
|
return $tea.cast(await this.callApi(params, req, runtime), new GetAccessConfigurationResponse({}));
|
|
@@ -5127,10 +5572,11 @@ class Client extends openapi_client_1.default {
|
|
|
5127
5572
|
async getDirectoryWithOptions(request, runtime) {
|
|
5128
5573
|
tea_util_1.default.validateModel(request);
|
|
5129
5574
|
let query = {};
|
|
5130
|
-
|
|
5575
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5576
|
+
query["DirectoryId"] = request.directoryId;
|
|
5577
|
+
}
|
|
5131
5578
|
let req = new $OpenApi.OpenApiRequest({
|
|
5132
5579
|
query: openapi_util_1.default.query(query),
|
|
5133
|
-
body: tea_util_1.default.toMap(request),
|
|
5134
5580
|
});
|
|
5135
5581
|
let params = new $OpenApi.Params({
|
|
5136
5582
|
action: "GetDirectory",
|
|
@@ -5140,7 +5586,7 @@ class Client extends openapi_client_1.default {
|
|
|
5140
5586
|
method: "POST",
|
|
5141
5587
|
authType: "AK",
|
|
5142
5588
|
style: "RPC",
|
|
5143
|
-
reqBodyType: "
|
|
5589
|
+
reqBodyType: "formData",
|
|
5144
5590
|
bodyType: "json",
|
|
5145
5591
|
});
|
|
5146
5592
|
return $tea.cast(await this.callApi(params, req, runtime), new GetDirectoryResponse({}));
|
|
@@ -5152,10 +5598,11 @@ class Client extends openapi_client_1.default {
|
|
|
5152
5598
|
async getDirectorySAMLServiceProviderInfoWithOptions(request, runtime) {
|
|
5153
5599
|
tea_util_1.default.validateModel(request);
|
|
5154
5600
|
let query = {};
|
|
5155
|
-
|
|
5601
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5602
|
+
query["DirectoryId"] = request.directoryId;
|
|
5603
|
+
}
|
|
5156
5604
|
let req = new $OpenApi.OpenApiRequest({
|
|
5157
5605
|
query: openapi_util_1.default.query(query),
|
|
5158
|
-
body: tea_util_1.default.toMap(request),
|
|
5159
5606
|
});
|
|
5160
5607
|
let params = new $OpenApi.Params({
|
|
5161
5608
|
action: "GetDirectorySAMLServiceProviderInfo",
|
|
@@ -5165,7 +5612,7 @@ class Client extends openapi_client_1.default {
|
|
|
5165
5612
|
method: "POST",
|
|
5166
5613
|
authType: "AK",
|
|
5167
5614
|
style: "RPC",
|
|
5168
|
-
reqBodyType: "
|
|
5615
|
+
reqBodyType: "formData",
|
|
5169
5616
|
bodyType: "json",
|
|
5170
5617
|
});
|
|
5171
5618
|
return $tea.cast(await this.callApi(params, req, runtime), new GetDirectorySAMLServiceProviderInfoResponse({}));
|
|
@@ -5177,10 +5624,11 @@ class Client extends openapi_client_1.default {
|
|
|
5177
5624
|
async getDirectoryStatisticsWithOptions(request, runtime) {
|
|
5178
5625
|
tea_util_1.default.validateModel(request);
|
|
5179
5626
|
let query = {};
|
|
5180
|
-
|
|
5627
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5628
|
+
query["DirectoryId"] = request.directoryId;
|
|
5629
|
+
}
|
|
5181
5630
|
let req = new $OpenApi.OpenApiRequest({
|
|
5182
5631
|
query: openapi_util_1.default.query(query),
|
|
5183
|
-
body: tea_util_1.default.toMap(request),
|
|
5184
5632
|
});
|
|
5185
5633
|
let params = new $OpenApi.Params({
|
|
5186
5634
|
action: "GetDirectoryStatistics",
|
|
@@ -5190,7 +5638,7 @@ class Client extends openapi_client_1.default {
|
|
|
5190
5638
|
method: "POST",
|
|
5191
5639
|
authType: "AK",
|
|
5192
5640
|
style: "RPC",
|
|
5193
|
-
reqBodyType: "
|
|
5641
|
+
reqBodyType: "formData",
|
|
5194
5642
|
bodyType: "json",
|
|
5195
5643
|
});
|
|
5196
5644
|
return $tea.cast(await this.callApi(params, req, runtime), new GetDirectoryStatisticsResponse({}));
|
|
@@ -5202,10 +5650,11 @@ class Client extends openapi_client_1.default {
|
|
|
5202
5650
|
async getExternalSAMLIdentityProviderWithOptions(request, runtime) {
|
|
5203
5651
|
tea_util_1.default.validateModel(request);
|
|
5204
5652
|
let query = {};
|
|
5205
|
-
|
|
5653
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5654
|
+
query["DirectoryId"] = request.directoryId;
|
|
5655
|
+
}
|
|
5206
5656
|
let req = new $OpenApi.OpenApiRequest({
|
|
5207
5657
|
query: openapi_util_1.default.query(query),
|
|
5208
|
-
body: tea_util_1.default.toMap(request),
|
|
5209
5658
|
});
|
|
5210
5659
|
let params = new $OpenApi.Params({
|
|
5211
5660
|
action: "GetExternalSAMLIdentityProvider",
|
|
@@ -5215,7 +5664,7 @@ class Client extends openapi_client_1.default {
|
|
|
5215
5664
|
method: "POST",
|
|
5216
5665
|
authType: "AK",
|
|
5217
5666
|
style: "RPC",
|
|
5218
|
-
reqBodyType: "
|
|
5667
|
+
reqBodyType: "formData",
|
|
5219
5668
|
bodyType: "json",
|
|
5220
5669
|
});
|
|
5221
5670
|
return $tea.cast(await this.callApi(params, req, runtime), new GetExternalSAMLIdentityProviderResponse({}));
|
|
@@ -5227,11 +5676,14 @@ class Client extends openapi_client_1.default {
|
|
|
5227
5676
|
async getGroupWithOptions(request, runtime) {
|
|
5228
5677
|
tea_util_1.default.validateModel(request);
|
|
5229
5678
|
let query = {};
|
|
5230
|
-
|
|
5231
|
-
|
|
5679
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5680
|
+
query["DirectoryId"] = request.directoryId;
|
|
5681
|
+
}
|
|
5682
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
5683
|
+
query["GroupId"] = request.groupId;
|
|
5684
|
+
}
|
|
5232
5685
|
let req = new $OpenApi.OpenApiRequest({
|
|
5233
5686
|
query: openapi_util_1.default.query(query),
|
|
5234
|
-
body: tea_util_1.default.toMap(request),
|
|
5235
5687
|
});
|
|
5236
5688
|
let params = new $OpenApi.Params({
|
|
5237
5689
|
action: "GetGroup",
|
|
@@ -5241,7 +5693,7 @@ class Client extends openapi_client_1.default {
|
|
|
5241
5693
|
method: "POST",
|
|
5242
5694
|
authType: "AK",
|
|
5243
5695
|
style: "RPC",
|
|
5244
|
-
reqBodyType: "
|
|
5696
|
+
reqBodyType: "formData",
|
|
5245
5697
|
bodyType: "json",
|
|
5246
5698
|
});
|
|
5247
5699
|
return $tea.cast(await this.callApi(params, req, runtime), new GetGroupResponse({}));
|
|
@@ -5250,13 +5702,40 @@ class Client extends openapi_client_1.default {
|
|
|
5250
5702
|
let runtime = new $Util.RuntimeOptions({});
|
|
5251
5703
|
return await this.getGroupWithOptions(request, runtime);
|
|
5252
5704
|
}
|
|
5705
|
+
async getMFAAuthenticationSettingsWithOptions(request, runtime) {
|
|
5706
|
+
tea_util_1.default.validateModel(request);
|
|
5707
|
+
let query = {};
|
|
5708
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5709
|
+
query["DirectoryId"] = request.directoryId;
|
|
5710
|
+
}
|
|
5711
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
5712
|
+
query: openapi_util_1.default.query(query),
|
|
5713
|
+
});
|
|
5714
|
+
let params = new $OpenApi.Params({
|
|
5715
|
+
action: "GetMFAAuthenticationSettings",
|
|
5716
|
+
version: "2021-05-15",
|
|
5717
|
+
protocol: "HTTPS",
|
|
5718
|
+
pathname: "/",
|
|
5719
|
+
method: "POST",
|
|
5720
|
+
authType: "AK",
|
|
5721
|
+
style: "RPC",
|
|
5722
|
+
reqBodyType: "formData",
|
|
5723
|
+
bodyType: "json",
|
|
5724
|
+
});
|
|
5725
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetMFAAuthenticationSettingsResponse({}));
|
|
5726
|
+
}
|
|
5727
|
+
async getMFAAuthenticationSettings(request) {
|
|
5728
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
5729
|
+
return await this.getMFAAuthenticationSettingsWithOptions(request, runtime);
|
|
5730
|
+
}
|
|
5253
5731
|
async getMFAAuthenticationStatusWithOptions(request, runtime) {
|
|
5254
5732
|
tea_util_1.default.validateModel(request);
|
|
5255
5733
|
let query = {};
|
|
5256
|
-
|
|
5734
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5735
|
+
query["DirectoryId"] = request.directoryId;
|
|
5736
|
+
}
|
|
5257
5737
|
let req = new $OpenApi.OpenApiRequest({
|
|
5258
5738
|
query: openapi_util_1.default.query(query),
|
|
5259
|
-
body: tea_util_1.default.toMap(request),
|
|
5260
5739
|
});
|
|
5261
5740
|
let params = new $OpenApi.Params({
|
|
5262
5741
|
action: "GetMFAAuthenticationStatus",
|
|
@@ -5266,7 +5745,7 @@ class Client extends openapi_client_1.default {
|
|
|
5266
5745
|
method: "POST",
|
|
5267
5746
|
authType: "AK",
|
|
5268
5747
|
style: "RPC",
|
|
5269
|
-
reqBodyType: "
|
|
5748
|
+
reqBodyType: "formData",
|
|
5270
5749
|
bodyType: "json",
|
|
5271
5750
|
});
|
|
5272
5751
|
return $tea.cast(await this.callApi(params, req, runtime), new GetMFAAuthenticationStatusResponse({}));
|
|
@@ -5278,10 +5757,11 @@ class Client extends openapi_client_1.default {
|
|
|
5278
5757
|
async getSCIMSynchronizationStatusWithOptions(request, runtime) {
|
|
5279
5758
|
tea_util_1.default.validateModel(request);
|
|
5280
5759
|
let query = {};
|
|
5281
|
-
|
|
5760
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5761
|
+
query["DirectoryId"] = request.directoryId;
|
|
5762
|
+
}
|
|
5282
5763
|
let req = new $OpenApi.OpenApiRequest({
|
|
5283
5764
|
query: openapi_util_1.default.query(query),
|
|
5284
|
-
body: tea_util_1.default.toMap(request),
|
|
5285
5765
|
});
|
|
5286
5766
|
let params = new $OpenApi.Params({
|
|
5287
5767
|
action: "GetSCIMSynchronizationStatus",
|
|
@@ -5291,7 +5771,7 @@ class Client extends openapi_client_1.default {
|
|
|
5291
5771
|
method: "POST",
|
|
5292
5772
|
authType: "AK",
|
|
5293
5773
|
style: "RPC",
|
|
5294
|
-
reqBodyType: "
|
|
5774
|
+
reqBodyType: "formData",
|
|
5295
5775
|
bodyType: "json",
|
|
5296
5776
|
});
|
|
5297
5777
|
return $tea.cast(await this.callApi(params, req, runtime), new GetSCIMSynchronizationStatusResponse({}));
|
|
@@ -5310,7 +5790,7 @@ class Client extends openapi_client_1.default {
|
|
|
5310
5790
|
method: "POST",
|
|
5311
5791
|
authType: "AK",
|
|
5312
5792
|
style: "RPC",
|
|
5313
|
-
reqBodyType: "
|
|
5793
|
+
reqBodyType: "formData",
|
|
5314
5794
|
bodyType: "json",
|
|
5315
5795
|
});
|
|
5316
5796
|
return $tea.cast(await this.callApi(params, req, runtime), new GetServiceStatusResponse({}));
|
|
@@ -5322,11 +5802,14 @@ class Client extends openapi_client_1.default {
|
|
|
5322
5802
|
async getTaskWithOptions(request, runtime) {
|
|
5323
5803
|
tea_util_1.default.validateModel(request);
|
|
5324
5804
|
let query = {};
|
|
5325
|
-
|
|
5326
|
-
|
|
5805
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5806
|
+
query["DirectoryId"] = request.directoryId;
|
|
5807
|
+
}
|
|
5808
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
5809
|
+
query["TaskId"] = request.taskId;
|
|
5810
|
+
}
|
|
5327
5811
|
let req = new $OpenApi.OpenApiRequest({
|
|
5328
5812
|
query: openapi_util_1.default.query(query),
|
|
5329
|
-
body: tea_util_1.default.toMap(request),
|
|
5330
5813
|
});
|
|
5331
5814
|
let params = new $OpenApi.Params({
|
|
5332
5815
|
action: "GetTask",
|
|
@@ -5336,7 +5819,7 @@ class Client extends openapi_client_1.default {
|
|
|
5336
5819
|
method: "POST",
|
|
5337
5820
|
authType: "AK",
|
|
5338
5821
|
style: "RPC",
|
|
5339
|
-
reqBodyType: "
|
|
5822
|
+
reqBodyType: "formData",
|
|
5340
5823
|
bodyType: "json",
|
|
5341
5824
|
});
|
|
5342
5825
|
return $tea.cast(await this.callApi(params, req, runtime), new GetTaskResponse({}));
|
|
@@ -5348,11 +5831,14 @@ class Client extends openapi_client_1.default {
|
|
|
5348
5831
|
async getTaskStatusWithOptions(request, runtime) {
|
|
5349
5832
|
tea_util_1.default.validateModel(request);
|
|
5350
5833
|
let query = {};
|
|
5351
|
-
|
|
5352
|
-
|
|
5834
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5835
|
+
query["DirectoryId"] = request.directoryId;
|
|
5836
|
+
}
|
|
5837
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
5838
|
+
query["TaskId"] = request.taskId;
|
|
5839
|
+
}
|
|
5353
5840
|
let req = new $OpenApi.OpenApiRequest({
|
|
5354
5841
|
query: openapi_util_1.default.query(query),
|
|
5355
|
-
body: tea_util_1.default.toMap(request),
|
|
5356
5842
|
});
|
|
5357
5843
|
let params = new $OpenApi.Params({
|
|
5358
5844
|
action: "GetTaskStatus",
|
|
@@ -5362,7 +5848,7 @@ class Client extends openapi_client_1.default {
|
|
|
5362
5848
|
method: "POST",
|
|
5363
5849
|
authType: "AK",
|
|
5364
5850
|
style: "RPC",
|
|
5365
|
-
reqBodyType: "
|
|
5851
|
+
reqBodyType: "formData",
|
|
5366
5852
|
bodyType: "json",
|
|
5367
5853
|
});
|
|
5368
5854
|
return $tea.cast(await this.callApi(params, req, runtime), new GetTaskStatusResponse({}));
|
|
@@ -5374,11 +5860,14 @@ class Client extends openapi_client_1.default {
|
|
|
5374
5860
|
async getUserWithOptions(request, runtime) {
|
|
5375
5861
|
tea_util_1.default.validateModel(request);
|
|
5376
5862
|
let query = {};
|
|
5377
|
-
|
|
5378
|
-
|
|
5863
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5864
|
+
query["DirectoryId"] = request.directoryId;
|
|
5865
|
+
}
|
|
5866
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
5867
|
+
query["UserId"] = request.userId;
|
|
5868
|
+
}
|
|
5379
5869
|
let req = new $OpenApi.OpenApiRequest({
|
|
5380
5870
|
query: openapi_util_1.default.query(query),
|
|
5381
|
-
body: tea_util_1.default.toMap(request),
|
|
5382
5871
|
});
|
|
5383
5872
|
let params = new $OpenApi.Params({
|
|
5384
5873
|
action: "GetUser",
|
|
@@ -5388,7 +5877,7 @@ class Client extends openapi_client_1.default {
|
|
|
5388
5877
|
method: "POST",
|
|
5389
5878
|
authType: "AK",
|
|
5390
5879
|
style: "RPC",
|
|
5391
|
-
reqBodyType: "
|
|
5880
|
+
reqBodyType: "formData",
|
|
5392
5881
|
bodyType: "json",
|
|
5393
5882
|
});
|
|
5394
5883
|
return $tea.cast(await this.callApi(params, req, runtime), new GetUserResponse({}));
|
|
@@ -5397,20 +5886,64 @@ class Client extends openapi_client_1.default {
|
|
|
5397
5886
|
let runtime = new $Util.RuntimeOptions({});
|
|
5398
5887
|
return await this.getUserWithOptions(request, runtime);
|
|
5399
5888
|
}
|
|
5889
|
+
async getUserMFAAuthenticationSettingsWithOptions(request, runtime) {
|
|
5890
|
+
tea_util_1.default.validateModel(request);
|
|
5891
|
+
let query = {};
|
|
5892
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5893
|
+
query["DirectoryId"] = request.directoryId;
|
|
5894
|
+
}
|
|
5895
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
5896
|
+
query["UserId"] = request.userId;
|
|
5897
|
+
}
|
|
5898
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
5899
|
+
query: openapi_util_1.default.query(query),
|
|
5900
|
+
});
|
|
5901
|
+
let params = new $OpenApi.Params({
|
|
5902
|
+
action: "GetUserMFAAuthenticationSettings",
|
|
5903
|
+
version: "2021-05-15",
|
|
5904
|
+
protocol: "HTTPS",
|
|
5905
|
+
pathname: "/",
|
|
5906
|
+
method: "POST",
|
|
5907
|
+
authType: "AK",
|
|
5908
|
+
style: "RPC",
|
|
5909
|
+
reqBodyType: "formData",
|
|
5910
|
+
bodyType: "json",
|
|
5911
|
+
});
|
|
5912
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetUserMFAAuthenticationSettingsResponse({}));
|
|
5913
|
+
}
|
|
5914
|
+
async getUserMFAAuthenticationSettings(request) {
|
|
5915
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
5916
|
+
return await this.getUserMFAAuthenticationSettingsWithOptions(request, runtime);
|
|
5917
|
+
}
|
|
5400
5918
|
async listAccessAssignmentsWithOptions(request, runtime) {
|
|
5401
5919
|
tea_util_1.default.validateModel(request);
|
|
5402
5920
|
let query = {};
|
|
5403
|
-
|
|
5404
|
-
|
|
5405
|
-
|
|
5406
|
-
|
|
5407
|
-
|
|
5408
|
-
|
|
5409
|
-
|
|
5410
|
-
|
|
5921
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5922
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5923
|
+
}
|
|
5924
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5925
|
+
query["DirectoryId"] = request.directoryId;
|
|
5926
|
+
}
|
|
5927
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
5928
|
+
query["MaxResults"] = request.maxResults;
|
|
5929
|
+
}
|
|
5930
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
5931
|
+
query["NextToken"] = request.nextToken;
|
|
5932
|
+
}
|
|
5933
|
+
if (!tea_util_1.default.isUnset(request.principalId)) {
|
|
5934
|
+
query["PrincipalId"] = request.principalId;
|
|
5935
|
+
}
|
|
5936
|
+
if (!tea_util_1.default.isUnset(request.principalType)) {
|
|
5937
|
+
query["PrincipalType"] = request.principalType;
|
|
5938
|
+
}
|
|
5939
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5940
|
+
query["TargetId"] = request.targetId;
|
|
5941
|
+
}
|
|
5942
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5943
|
+
query["TargetType"] = request.targetType;
|
|
5944
|
+
}
|
|
5411
5945
|
let req = new $OpenApi.OpenApiRequest({
|
|
5412
5946
|
query: openapi_util_1.default.query(query),
|
|
5413
|
-
body: tea_util_1.default.toMap(request),
|
|
5414
5947
|
});
|
|
5415
5948
|
let params = new $OpenApi.Params({
|
|
5416
5949
|
action: "ListAccessAssignments",
|
|
@@ -5420,7 +5953,7 @@ class Client extends openapi_client_1.default {
|
|
|
5420
5953
|
method: "POST",
|
|
5421
5954
|
authType: "AK",
|
|
5422
5955
|
style: "RPC",
|
|
5423
|
-
reqBodyType: "
|
|
5956
|
+
reqBodyType: "formData",
|
|
5424
5957
|
bodyType: "json",
|
|
5425
5958
|
});
|
|
5426
5959
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAccessAssignmentsResponse({}));
|
|
@@ -5432,16 +5965,29 @@ class Client extends openapi_client_1.default {
|
|
|
5432
5965
|
async listAccessConfigurationProvisioningsWithOptions(request, runtime) {
|
|
5433
5966
|
tea_util_1.default.validateModel(request);
|
|
5434
5967
|
let query = {};
|
|
5435
|
-
|
|
5436
|
-
|
|
5437
|
-
|
|
5438
|
-
|
|
5439
|
-
|
|
5440
|
-
|
|
5441
|
-
|
|
5968
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
5969
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
5970
|
+
}
|
|
5971
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
5972
|
+
query["DirectoryId"] = request.directoryId;
|
|
5973
|
+
}
|
|
5974
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
5975
|
+
query["MaxResults"] = request.maxResults;
|
|
5976
|
+
}
|
|
5977
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
5978
|
+
query["NextToken"] = request.nextToken;
|
|
5979
|
+
}
|
|
5980
|
+
if (!tea_util_1.default.isUnset(request.provisioningStatus)) {
|
|
5981
|
+
query["ProvisioningStatus"] = request.provisioningStatus;
|
|
5982
|
+
}
|
|
5983
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
5984
|
+
query["TargetId"] = request.targetId;
|
|
5985
|
+
}
|
|
5986
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
5987
|
+
query["TargetType"] = request.targetType;
|
|
5988
|
+
}
|
|
5442
5989
|
let req = new $OpenApi.OpenApiRequest({
|
|
5443
5990
|
query: openapi_util_1.default.query(query),
|
|
5444
|
-
body: tea_util_1.default.toMap(request),
|
|
5445
5991
|
});
|
|
5446
5992
|
let params = new $OpenApi.Params({
|
|
5447
5993
|
action: "ListAccessConfigurationProvisionings",
|
|
@@ -5451,7 +5997,7 @@ class Client extends openapi_client_1.default {
|
|
|
5451
5997
|
method: "POST",
|
|
5452
5998
|
authType: "AK",
|
|
5453
5999
|
style: "RPC",
|
|
5454
|
-
reqBodyType: "
|
|
6000
|
+
reqBodyType: "formData",
|
|
5455
6001
|
bodyType: "json",
|
|
5456
6002
|
});
|
|
5457
6003
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAccessConfigurationProvisioningsResponse({}));
|
|
@@ -5463,14 +6009,23 @@ class Client extends openapi_client_1.default {
|
|
|
5463
6009
|
async listAccessConfigurationsWithOptions(request, runtime) {
|
|
5464
6010
|
tea_util_1.default.validateModel(request);
|
|
5465
6011
|
let query = {};
|
|
5466
|
-
|
|
5467
|
-
|
|
5468
|
-
|
|
5469
|
-
|
|
5470
|
-
|
|
6012
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6013
|
+
query["DirectoryId"] = request.directoryId;
|
|
6014
|
+
}
|
|
6015
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
6016
|
+
query["Filter"] = request.filter;
|
|
6017
|
+
}
|
|
6018
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6019
|
+
query["MaxResults"] = request.maxResults;
|
|
6020
|
+
}
|
|
6021
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6022
|
+
query["NextToken"] = request.nextToken;
|
|
6023
|
+
}
|
|
6024
|
+
if (!tea_util_1.default.isUnset(request.statusNotifications)) {
|
|
6025
|
+
query["StatusNotifications"] = request.statusNotifications;
|
|
6026
|
+
}
|
|
5471
6027
|
let req = new $OpenApi.OpenApiRequest({
|
|
5472
6028
|
query: openapi_util_1.default.query(query),
|
|
5473
|
-
body: tea_util_1.default.toMap(request),
|
|
5474
6029
|
});
|
|
5475
6030
|
let params = new $OpenApi.Params({
|
|
5476
6031
|
action: "ListAccessConfigurations",
|
|
@@ -5480,7 +6035,7 @@ class Client extends openapi_client_1.default {
|
|
|
5480
6035
|
method: "POST",
|
|
5481
6036
|
authType: "AK",
|
|
5482
6037
|
style: "RPC",
|
|
5483
|
-
reqBodyType: "
|
|
6038
|
+
reqBodyType: "formData",
|
|
5484
6039
|
bodyType: "json",
|
|
5485
6040
|
});
|
|
5486
6041
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAccessConfigurationsResponse({}));
|
|
@@ -5499,7 +6054,7 @@ class Client extends openapi_client_1.default {
|
|
|
5499
6054
|
method: "POST",
|
|
5500
6055
|
authType: "AK",
|
|
5501
6056
|
style: "RPC",
|
|
5502
|
-
reqBodyType: "
|
|
6057
|
+
reqBodyType: "formData",
|
|
5503
6058
|
bodyType: "json",
|
|
5504
6059
|
});
|
|
5505
6060
|
return $tea.cast(await this.callApi(params, req, runtime), new ListDirectoriesResponse({}));
|
|
@@ -5511,10 +6066,11 @@ class Client extends openapi_client_1.default {
|
|
|
5511
6066
|
async listExternalSAMLIdPCertificatesWithOptions(request, runtime) {
|
|
5512
6067
|
tea_util_1.default.validateModel(request);
|
|
5513
6068
|
let query = {};
|
|
5514
|
-
|
|
6069
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6070
|
+
query["DirectoryId"] = request.directoryId;
|
|
6071
|
+
}
|
|
5515
6072
|
let req = new $OpenApi.OpenApiRequest({
|
|
5516
6073
|
query: openapi_util_1.default.query(query),
|
|
5517
|
-
body: tea_util_1.default.toMap(request),
|
|
5518
6074
|
});
|
|
5519
6075
|
let params = new $OpenApi.Params({
|
|
5520
6076
|
action: "ListExternalSAMLIdPCertificates",
|
|
@@ -5524,7 +6080,7 @@ class Client extends openapi_client_1.default {
|
|
|
5524
6080
|
method: "POST",
|
|
5525
6081
|
authType: "AK",
|
|
5526
6082
|
style: "RPC",
|
|
5527
|
-
reqBodyType: "
|
|
6083
|
+
reqBodyType: "formData",
|
|
5528
6084
|
bodyType: "json",
|
|
5529
6085
|
});
|
|
5530
6086
|
return $tea.cast(await this.callApi(params, req, runtime), new ListExternalSAMLIdPCertificatesResponse({}));
|
|
@@ -5536,13 +6092,20 @@ class Client extends openapi_client_1.default {
|
|
|
5536
6092
|
async listGroupMembersWithOptions(request, runtime) {
|
|
5537
6093
|
tea_util_1.default.validateModel(request);
|
|
5538
6094
|
let query = {};
|
|
5539
|
-
|
|
5540
|
-
|
|
5541
|
-
|
|
5542
|
-
|
|
6095
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6096
|
+
query["DirectoryId"] = request.directoryId;
|
|
6097
|
+
}
|
|
6098
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
6099
|
+
query["GroupId"] = request.groupId;
|
|
6100
|
+
}
|
|
6101
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6102
|
+
query["MaxResults"] = request.maxResults;
|
|
6103
|
+
}
|
|
6104
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6105
|
+
query["NextToken"] = request.nextToken;
|
|
6106
|
+
}
|
|
5543
6107
|
let req = new $OpenApi.OpenApiRequest({
|
|
5544
6108
|
query: openapi_util_1.default.query(query),
|
|
5545
|
-
body: tea_util_1.default.toMap(request),
|
|
5546
6109
|
});
|
|
5547
6110
|
let params = new $OpenApi.Params({
|
|
5548
6111
|
action: "ListGroupMembers",
|
|
@@ -5552,7 +6115,7 @@ class Client extends openapi_client_1.default {
|
|
|
5552
6115
|
method: "POST",
|
|
5553
6116
|
authType: "AK",
|
|
5554
6117
|
style: "RPC",
|
|
5555
|
-
reqBodyType: "
|
|
6118
|
+
reqBodyType: "formData",
|
|
5556
6119
|
bodyType: "json",
|
|
5557
6120
|
});
|
|
5558
6121
|
return $tea.cast(await this.callApi(params, req, runtime), new ListGroupMembersResponse({}));
|
|
@@ -5564,14 +6127,23 @@ class Client extends openapi_client_1.default {
|
|
|
5564
6127
|
async listGroupsWithOptions(request, runtime) {
|
|
5565
6128
|
tea_util_1.default.validateModel(request);
|
|
5566
6129
|
let query = {};
|
|
5567
|
-
|
|
5568
|
-
|
|
5569
|
-
|
|
5570
|
-
|
|
5571
|
-
|
|
6130
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6131
|
+
query["DirectoryId"] = request.directoryId;
|
|
6132
|
+
}
|
|
6133
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
6134
|
+
query["Filter"] = request.filter;
|
|
6135
|
+
}
|
|
6136
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6137
|
+
query["MaxResults"] = request.maxResults;
|
|
6138
|
+
}
|
|
6139
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6140
|
+
query["NextToken"] = request.nextToken;
|
|
6141
|
+
}
|
|
6142
|
+
if (!tea_util_1.default.isUnset(request.provisionType)) {
|
|
6143
|
+
query["ProvisionType"] = request.provisionType;
|
|
6144
|
+
}
|
|
5572
6145
|
let req = new $OpenApi.OpenApiRequest({
|
|
5573
6146
|
query: openapi_util_1.default.query(query),
|
|
5574
|
-
body: tea_util_1.default.toMap(request),
|
|
5575
6147
|
});
|
|
5576
6148
|
let params = new $OpenApi.Params({
|
|
5577
6149
|
action: "ListGroups",
|
|
@@ -5581,7 +6153,7 @@ class Client extends openapi_client_1.default {
|
|
|
5581
6153
|
method: "POST",
|
|
5582
6154
|
authType: "AK",
|
|
5583
6155
|
style: "RPC",
|
|
5584
|
-
reqBodyType: "
|
|
6156
|
+
reqBodyType: "formData",
|
|
5585
6157
|
bodyType: "json",
|
|
5586
6158
|
});
|
|
5587
6159
|
return $tea.cast(await this.callApi(params, req, runtime), new ListGroupsResponse({}));
|
|
@@ -5593,13 +6165,20 @@ class Client extends openapi_client_1.default {
|
|
|
5593
6165
|
async listJoinedGroupsForUserWithOptions(request, runtime) {
|
|
5594
6166
|
tea_util_1.default.validateModel(request);
|
|
5595
6167
|
let query = {};
|
|
5596
|
-
|
|
5597
|
-
|
|
5598
|
-
|
|
5599
|
-
|
|
6168
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6169
|
+
query["DirectoryId"] = request.directoryId;
|
|
6170
|
+
}
|
|
6171
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6172
|
+
query["MaxResults"] = request.maxResults;
|
|
6173
|
+
}
|
|
6174
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6175
|
+
query["NextToken"] = request.nextToken;
|
|
6176
|
+
}
|
|
6177
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6178
|
+
query["UserId"] = request.userId;
|
|
6179
|
+
}
|
|
5600
6180
|
let req = new $OpenApi.OpenApiRequest({
|
|
5601
6181
|
query: openapi_util_1.default.query(query),
|
|
5602
|
-
body: tea_util_1.default.toMap(request),
|
|
5603
6182
|
});
|
|
5604
6183
|
let params = new $OpenApi.Params({
|
|
5605
6184
|
action: "ListJoinedGroupsForUser",
|
|
@@ -5609,7 +6188,7 @@ class Client extends openapi_client_1.default {
|
|
|
5609
6188
|
method: "POST",
|
|
5610
6189
|
authType: "AK",
|
|
5611
6190
|
style: "RPC",
|
|
5612
|
-
reqBodyType: "
|
|
6191
|
+
reqBodyType: "formData",
|
|
5613
6192
|
bodyType: "json",
|
|
5614
6193
|
});
|
|
5615
6194
|
return $tea.cast(await this.callApi(params, req, runtime), new ListJoinedGroupsForUserResponse({}));
|
|
@@ -5621,11 +6200,14 @@ class Client extends openapi_client_1.default {
|
|
|
5621
6200
|
async listMFADevicesForUserWithOptions(request, runtime) {
|
|
5622
6201
|
tea_util_1.default.validateModel(request);
|
|
5623
6202
|
let query = {};
|
|
5624
|
-
|
|
5625
|
-
|
|
6203
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6204
|
+
query["DirectoryId"] = request.directoryId;
|
|
6205
|
+
}
|
|
6206
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6207
|
+
query["UserId"] = request.userId;
|
|
6208
|
+
}
|
|
5626
6209
|
let req = new $OpenApi.OpenApiRequest({
|
|
5627
6210
|
query: openapi_util_1.default.query(query),
|
|
5628
|
-
body: tea_util_1.default.toMap(request),
|
|
5629
6211
|
});
|
|
5630
6212
|
let params = new $OpenApi.Params({
|
|
5631
6213
|
action: "ListMFADevicesForUser",
|
|
@@ -5635,7 +6217,7 @@ class Client extends openapi_client_1.default {
|
|
|
5635
6217
|
method: "POST",
|
|
5636
6218
|
authType: "AK",
|
|
5637
6219
|
style: "RPC",
|
|
5638
|
-
reqBodyType: "
|
|
6220
|
+
reqBodyType: "formData",
|
|
5639
6221
|
bodyType: "json",
|
|
5640
6222
|
});
|
|
5641
6223
|
return $tea.cast(await this.callApi(params, req, runtime), new ListMFADevicesForUserResponse({}));
|
|
@@ -5647,12 +6229,17 @@ class Client extends openapi_client_1.default {
|
|
|
5647
6229
|
async listPermissionPoliciesInAccessConfigurationWithOptions(request, runtime) {
|
|
5648
6230
|
tea_util_1.default.validateModel(request);
|
|
5649
6231
|
let query = {};
|
|
5650
|
-
|
|
5651
|
-
|
|
5652
|
-
|
|
6232
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6233
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6234
|
+
}
|
|
6235
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6236
|
+
query["DirectoryId"] = request.directoryId;
|
|
6237
|
+
}
|
|
6238
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyType)) {
|
|
6239
|
+
query["PermissionPolicyType"] = request.permissionPolicyType;
|
|
6240
|
+
}
|
|
5653
6241
|
let req = new $OpenApi.OpenApiRequest({
|
|
5654
6242
|
query: openapi_util_1.default.query(query),
|
|
5655
|
-
body: tea_util_1.default.toMap(request),
|
|
5656
6243
|
});
|
|
5657
6244
|
let params = new $OpenApi.Params({
|
|
5658
6245
|
action: "ListPermissionPoliciesInAccessConfiguration",
|
|
@@ -5662,7 +6249,7 @@ class Client extends openapi_client_1.default {
|
|
|
5662
6249
|
method: "POST",
|
|
5663
6250
|
authType: "AK",
|
|
5664
6251
|
style: "RPC",
|
|
5665
|
-
reqBodyType: "
|
|
6252
|
+
reqBodyType: "formData",
|
|
5666
6253
|
bodyType: "json",
|
|
5667
6254
|
});
|
|
5668
6255
|
return $tea.cast(await this.callApi(params, req, runtime), new ListPermissionPoliciesInAccessConfigurationResponse({}));
|
|
@@ -5674,10 +6261,11 @@ class Client extends openapi_client_1.default {
|
|
|
5674
6261
|
async listSCIMServerCredentialsWithOptions(request, runtime) {
|
|
5675
6262
|
tea_util_1.default.validateModel(request);
|
|
5676
6263
|
let query = {};
|
|
5677
|
-
|
|
6264
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6265
|
+
query["DirectoryId"] = request.directoryId;
|
|
6266
|
+
}
|
|
5678
6267
|
let req = new $OpenApi.OpenApiRequest({
|
|
5679
6268
|
query: openapi_util_1.default.query(query),
|
|
5680
|
-
body: tea_util_1.default.toMap(request),
|
|
5681
6269
|
});
|
|
5682
6270
|
let params = new $OpenApi.Params({
|
|
5683
6271
|
action: "ListSCIMServerCredentials",
|
|
@@ -5687,7 +6275,7 @@ class Client extends openapi_client_1.default {
|
|
|
5687
6275
|
method: "POST",
|
|
5688
6276
|
authType: "AK",
|
|
5689
6277
|
style: "RPC",
|
|
5690
|
-
reqBodyType: "
|
|
6278
|
+
reqBodyType: "formData",
|
|
5691
6279
|
bodyType: "json",
|
|
5692
6280
|
});
|
|
5693
6281
|
return $tea.cast(await this.callApi(params, req, runtime), new ListSCIMServerCredentialsResponse({}));
|
|
@@ -5699,20 +6287,41 @@ class Client extends openapi_client_1.default {
|
|
|
5699
6287
|
async listTasksWithOptions(request, runtime) {
|
|
5700
6288
|
tea_util_1.default.validateModel(request);
|
|
5701
6289
|
let query = {};
|
|
5702
|
-
|
|
5703
|
-
|
|
5704
|
-
|
|
5705
|
-
|
|
5706
|
-
|
|
5707
|
-
|
|
5708
|
-
|
|
5709
|
-
|
|
5710
|
-
|
|
5711
|
-
|
|
5712
|
-
|
|
6290
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6291
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6292
|
+
}
|
|
6293
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6294
|
+
query["DirectoryId"] = request.directoryId;
|
|
6295
|
+
}
|
|
6296
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
6297
|
+
query["Filter"] = request.filter;
|
|
6298
|
+
}
|
|
6299
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6300
|
+
query["MaxResults"] = request.maxResults;
|
|
6301
|
+
}
|
|
6302
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6303
|
+
query["NextToken"] = request.nextToken;
|
|
6304
|
+
}
|
|
6305
|
+
if (!tea_util_1.default.isUnset(request.principalId)) {
|
|
6306
|
+
query["PrincipalId"] = request.principalId;
|
|
6307
|
+
}
|
|
6308
|
+
if (!tea_util_1.default.isUnset(request.principalType)) {
|
|
6309
|
+
query["PrincipalType"] = request.principalType;
|
|
6310
|
+
}
|
|
6311
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
6312
|
+
query["Status"] = request.status;
|
|
6313
|
+
}
|
|
6314
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
6315
|
+
query["TargetId"] = request.targetId;
|
|
6316
|
+
}
|
|
6317
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
6318
|
+
query["TargetType"] = request.targetType;
|
|
6319
|
+
}
|
|
6320
|
+
if (!tea_util_1.default.isUnset(request.taskType)) {
|
|
6321
|
+
query["TaskType"] = request.taskType;
|
|
6322
|
+
}
|
|
5713
6323
|
let req = new $OpenApi.OpenApiRequest({
|
|
5714
6324
|
query: openapi_util_1.default.query(query),
|
|
5715
|
-
body: tea_util_1.default.toMap(request),
|
|
5716
6325
|
});
|
|
5717
6326
|
let params = new $OpenApi.Params({
|
|
5718
6327
|
action: "ListTasks",
|
|
@@ -5722,7 +6331,7 @@ class Client extends openapi_client_1.default {
|
|
|
5722
6331
|
method: "POST",
|
|
5723
6332
|
authType: "AK",
|
|
5724
6333
|
style: "RPC",
|
|
5725
|
-
reqBodyType: "
|
|
6334
|
+
reqBodyType: "formData",
|
|
5726
6335
|
bodyType: "json",
|
|
5727
6336
|
});
|
|
5728
6337
|
return $tea.cast(await this.callApi(params, req, runtime), new ListTasksResponse({}));
|
|
@@ -5734,15 +6343,26 @@ class Client extends openapi_client_1.default {
|
|
|
5734
6343
|
async listUsersWithOptions(request, runtime) {
|
|
5735
6344
|
tea_util_1.default.validateModel(request);
|
|
5736
6345
|
let query = {};
|
|
5737
|
-
|
|
5738
|
-
|
|
5739
|
-
|
|
5740
|
-
|
|
5741
|
-
|
|
5742
|
-
|
|
6346
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6347
|
+
query["DirectoryId"] = request.directoryId;
|
|
6348
|
+
}
|
|
6349
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
6350
|
+
query["Filter"] = request.filter;
|
|
6351
|
+
}
|
|
6352
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
6353
|
+
query["MaxResults"] = request.maxResults;
|
|
6354
|
+
}
|
|
6355
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
6356
|
+
query["NextToken"] = request.nextToken;
|
|
6357
|
+
}
|
|
6358
|
+
if (!tea_util_1.default.isUnset(request.provisionType)) {
|
|
6359
|
+
query["ProvisionType"] = request.provisionType;
|
|
6360
|
+
}
|
|
6361
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
6362
|
+
query["Status"] = request.status;
|
|
6363
|
+
}
|
|
5743
6364
|
let req = new $OpenApi.OpenApiRequest({
|
|
5744
6365
|
query: openapi_util_1.default.query(query),
|
|
5745
|
-
body: tea_util_1.default.toMap(request),
|
|
5746
6366
|
});
|
|
5747
6367
|
let params = new $OpenApi.Params({
|
|
5748
6368
|
action: "ListUsers",
|
|
@@ -5752,7 +6372,7 @@ class Client extends openapi_client_1.default {
|
|
|
5752
6372
|
method: "POST",
|
|
5753
6373
|
authType: "AK",
|
|
5754
6374
|
style: "RPC",
|
|
5755
|
-
reqBodyType: "
|
|
6375
|
+
reqBodyType: "formData",
|
|
5756
6376
|
bodyType: "json",
|
|
5757
6377
|
});
|
|
5758
6378
|
return $tea.cast(await this.callApi(params, req, runtime), new ListUsersResponse({}));
|
|
@@ -5764,13 +6384,20 @@ class Client extends openapi_client_1.default {
|
|
|
5764
6384
|
async provisionAccessConfigurationWithOptions(request, runtime) {
|
|
5765
6385
|
tea_util_1.default.validateModel(request);
|
|
5766
6386
|
let query = {};
|
|
5767
|
-
|
|
5768
|
-
|
|
5769
|
-
|
|
5770
|
-
|
|
6387
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6388
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6389
|
+
}
|
|
6390
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6391
|
+
query["DirectoryId"] = request.directoryId;
|
|
6392
|
+
}
|
|
6393
|
+
if (!tea_util_1.default.isUnset(request.targetId)) {
|
|
6394
|
+
query["TargetId"] = request.targetId;
|
|
6395
|
+
}
|
|
6396
|
+
if (!tea_util_1.default.isUnset(request.targetType)) {
|
|
6397
|
+
query["TargetType"] = request.targetType;
|
|
6398
|
+
}
|
|
5771
6399
|
let req = new $OpenApi.OpenApiRequest({
|
|
5772
6400
|
query: openapi_util_1.default.query(query),
|
|
5773
|
-
body: tea_util_1.default.toMap(request),
|
|
5774
6401
|
});
|
|
5775
6402
|
let params = new $OpenApi.Params({
|
|
5776
6403
|
action: "ProvisionAccessConfiguration",
|
|
@@ -5780,7 +6407,7 @@ class Client extends openapi_client_1.default {
|
|
|
5780
6407
|
method: "POST",
|
|
5781
6408
|
authType: "AK",
|
|
5782
6409
|
style: "RPC",
|
|
5783
|
-
reqBodyType: "
|
|
6410
|
+
reqBodyType: "formData",
|
|
5784
6411
|
bodyType: "json",
|
|
5785
6412
|
});
|
|
5786
6413
|
return $tea.cast(await this.callApi(params, req, runtime), new ProvisionAccessConfigurationResponse({}));
|
|
@@ -5792,11 +6419,14 @@ class Client extends openapi_client_1.default {
|
|
|
5792
6419
|
async removeExternalSAMLIdPCertificateWithOptions(request, runtime) {
|
|
5793
6420
|
tea_util_1.default.validateModel(request);
|
|
5794
6421
|
let query = {};
|
|
5795
|
-
|
|
5796
|
-
|
|
6422
|
+
if (!tea_util_1.default.isUnset(request.certificateId)) {
|
|
6423
|
+
query["CertificateId"] = request.certificateId;
|
|
6424
|
+
}
|
|
6425
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6426
|
+
query["DirectoryId"] = request.directoryId;
|
|
6427
|
+
}
|
|
5797
6428
|
let req = new $OpenApi.OpenApiRequest({
|
|
5798
6429
|
query: openapi_util_1.default.query(query),
|
|
5799
|
-
body: tea_util_1.default.toMap(request),
|
|
5800
6430
|
});
|
|
5801
6431
|
let params = new $OpenApi.Params({
|
|
5802
6432
|
action: "RemoveExternalSAMLIdPCertificate",
|
|
@@ -5806,7 +6436,7 @@ class Client extends openapi_client_1.default {
|
|
|
5806
6436
|
method: "POST",
|
|
5807
6437
|
authType: "AK",
|
|
5808
6438
|
style: "RPC",
|
|
5809
|
-
reqBodyType: "
|
|
6439
|
+
reqBodyType: "formData",
|
|
5810
6440
|
bodyType: "json",
|
|
5811
6441
|
});
|
|
5812
6442
|
return $tea.cast(await this.callApi(params, req, runtime), new RemoveExternalSAMLIdPCertificateResponse({}));
|
|
@@ -5818,13 +6448,20 @@ class Client extends openapi_client_1.default {
|
|
|
5818
6448
|
async removePermissionPolicyFromAccessConfigurationWithOptions(request, runtime) {
|
|
5819
6449
|
tea_util_1.default.validateModel(request);
|
|
5820
6450
|
let query = {};
|
|
5821
|
-
|
|
5822
|
-
|
|
5823
|
-
|
|
5824
|
-
|
|
6451
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6452
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6453
|
+
}
|
|
6454
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6455
|
+
query["DirectoryId"] = request.directoryId;
|
|
6456
|
+
}
|
|
6457
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyName)) {
|
|
6458
|
+
query["PermissionPolicyName"] = request.permissionPolicyName;
|
|
6459
|
+
}
|
|
6460
|
+
if (!tea_util_1.default.isUnset(request.permissionPolicyType)) {
|
|
6461
|
+
query["PermissionPolicyType"] = request.permissionPolicyType;
|
|
6462
|
+
}
|
|
5825
6463
|
let req = new $OpenApi.OpenApiRequest({
|
|
5826
6464
|
query: openapi_util_1.default.query(query),
|
|
5827
|
-
body: tea_util_1.default.toMap(request),
|
|
5828
6465
|
});
|
|
5829
6466
|
let params = new $OpenApi.Params({
|
|
5830
6467
|
action: "RemovePermissionPolicyFromAccessConfiguration",
|
|
@@ -5834,7 +6471,7 @@ class Client extends openapi_client_1.default {
|
|
|
5834
6471
|
method: "POST",
|
|
5835
6472
|
authType: "AK",
|
|
5836
6473
|
style: "RPC",
|
|
5837
|
-
reqBodyType: "
|
|
6474
|
+
reqBodyType: "formData",
|
|
5838
6475
|
bodyType: "json",
|
|
5839
6476
|
});
|
|
5840
6477
|
return $tea.cast(await this.callApi(params, req, runtime), new RemovePermissionPolicyFromAccessConfigurationResponse({}));
|
|
@@ -5846,12 +6483,17 @@ class Client extends openapi_client_1.default {
|
|
|
5846
6483
|
async removeUserFromGroupWithOptions(request, runtime) {
|
|
5847
6484
|
tea_util_1.default.validateModel(request);
|
|
5848
6485
|
let query = {};
|
|
5849
|
-
|
|
5850
|
-
|
|
5851
|
-
|
|
6486
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6487
|
+
query["DirectoryId"] = request.directoryId;
|
|
6488
|
+
}
|
|
6489
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
6490
|
+
query["GroupId"] = request.groupId;
|
|
6491
|
+
}
|
|
6492
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6493
|
+
query["UserId"] = request.userId;
|
|
6494
|
+
}
|
|
5852
6495
|
let req = new $OpenApi.OpenApiRequest({
|
|
5853
6496
|
query: openapi_util_1.default.query(query),
|
|
5854
|
-
body: tea_util_1.default.toMap(request),
|
|
5855
6497
|
});
|
|
5856
6498
|
let params = new $OpenApi.Params({
|
|
5857
6499
|
action: "RemoveUserFromGroup",
|
|
@@ -5861,7 +6503,7 @@ class Client extends openapi_client_1.default {
|
|
|
5861
6503
|
method: "POST",
|
|
5862
6504
|
authType: "AK",
|
|
5863
6505
|
style: "RPC",
|
|
5864
|
-
reqBodyType: "
|
|
6506
|
+
reqBodyType: "formData",
|
|
5865
6507
|
bodyType: "json",
|
|
5866
6508
|
});
|
|
5867
6509
|
return $tea.cast(await this.callApi(params, req, runtime), new RemoveUserFromGroupResponse({}));
|
|
@@ -5873,14 +6515,23 @@ class Client extends openapi_client_1.default {
|
|
|
5873
6515
|
async resetUserPasswordWithOptions(request, runtime) {
|
|
5874
6516
|
tea_util_1.default.validateModel(request);
|
|
5875
6517
|
let query = {};
|
|
5876
|
-
|
|
5877
|
-
|
|
5878
|
-
|
|
5879
|
-
|
|
5880
|
-
|
|
6518
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6519
|
+
query["DirectoryId"] = request.directoryId;
|
|
6520
|
+
}
|
|
6521
|
+
if (!tea_util_1.default.isUnset(request.generateRandomPassword)) {
|
|
6522
|
+
query["GenerateRandomPassword"] = request.generateRandomPassword;
|
|
6523
|
+
}
|
|
6524
|
+
if (!tea_util_1.default.isUnset(request.password)) {
|
|
6525
|
+
query["Password"] = request.password;
|
|
6526
|
+
}
|
|
6527
|
+
if (!tea_util_1.default.isUnset(request.requirePasswordResetForNextLogin)) {
|
|
6528
|
+
query["RequirePasswordResetForNextLogin"] = request.requirePasswordResetForNextLogin;
|
|
6529
|
+
}
|
|
6530
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6531
|
+
query["UserId"] = request.userId;
|
|
6532
|
+
}
|
|
5881
6533
|
let req = new $OpenApi.OpenApiRequest({
|
|
5882
6534
|
query: openapi_util_1.default.query(query),
|
|
5883
|
-
body: tea_util_1.default.toMap(request),
|
|
5884
6535
|
});
|
|
5885
6536
|
let params = new $OpenApi.Params({
|
|
5886
6537
|
action: "ResetUserPassword",
|
|
@@ -5890,7 +6541,7 @@ class Client extends openapi_client_1.default {
|
|
|
5890
6541
|
method: "POST",
|
|
5891
6542
|
authType: "AK",
|
|
5892
6543
|
style: "RPC",
|
|
5893
|
-
reqBodyType: "
|
|
6544
|
+
reqBodyType: "formData",
|
|
5894
6545
|
bodyType: "json",
|
|
5895
6546
|
});
|
|
5896
6547
|
return $tea.cast(await this.callApi(params, req, runtime), new ResetUserPasswordResponse({}));
|
|
@@ -5902,16 +6553,29 @@ class Client extends openapi_client_1.default {
|
|
|
5902
6553
|
async setExternalSAMLIdentityProviderWithOptions(request, runtime) {
|
|
5903
6554
|
tea_util_1.default.validateModel(request);
|
|
5904
6555
|
let query = {};
|
|
5905
|
-
|
|
5906
|
-
|
|
5907
|
-
|
|
5908
|
-
|
|
5909
|
-
|
|
5910
|
-
|
|
5911
|
-
|
|
6556
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6557
|
+
query["DirectoryId"] = request.directoryId;
|
|
6558
|
+
}
|
|
6559
|
+
if (!tea_util_1.default.isUnset(request.encodedMetadataDocument)) {
|
|
6560
|
+
query["EncodedMetadataDocument"] = request.encodedMetadataDocument;
|
|
6561
|
+
}
|
|
6562
|
+
if (!tea_util_1.default.isUnset(request.entityId)) {
|
|
6563
|
+
query["EntityId"] = request.entityId;
|
|
6564
|
+
}
|
|
6565
|
+
if (!tea_util_1.default.isUnset(request.loginUrl)) {
|
|
6566
|
+
query["LoginUrl"] = request.loginUrl;
|
|
6567
|
+
}
|
|
6568
|
+
if (!tea_util_1.default.isUnset(request.SSOStatus)) {
|
|
6569
|
+
query["SSOStatus"] = request.SSOStatus;
|
|
6570
|
+
}
|
|
6571
|
+
if (!tea_util_1.default.isUnset(request.wantRequestSigned)) {
|
|
6572
|
+
query["WantRequestSigned"] = request.wantRequestSigned;
|
|
6573
|
+
}
|
|
6574
|
+
if (!tea_util_1.default.isUnset(request.x509Certificate)) {
|
|
6575
|
+
query["X509Certificate"] = request.x509Certificate;
|
|
6576
|
+
}
|
|
5912
6577
|
let req = new $OpenApi.OpenApiRequest({
|
|
5913
6578
|
query: openapi_util_1.default.query(query),
|
|
5914
|
-
body: tea_util_1.default.toMap(request),
|
|
5915
6579
|
});
|
|
5916
6580
|
let params = new $OpenApi.Params({
|
|
5917
6581
|
action: "SetExternalSAMLIdentityProvider",
|
|
@@ -5921,7 +6585,7 @@ class Client extends openapi_client_1.default {
|
|
|
5921
6585
|
method: "POST",
|
|
5922
6586
|
authType: "AK",
|
|
5923
6587
|
style: "RPC",
|
|
5924
|
-
reqBodyType: "
|
|
6588
|
+
reqBodyType: "formData",
|
|
5925
6589
|
bodyType: "json",
|
|
5926
6590
|
});
|
|
5927
6591
|
return $tea.cast(await this.callApi(params, req, runtime), new SetExternalSAMLIdentityProviderResponse({}));
|
|
@@ -5933,11 +6597,14 @@ class Client extends openapi_client_1.default {
|
|
|
5933
6597
|
async setMFAAuthenticationStatusWithOptions(request, runtime) {
|
|
5934
6598
|
tea_util_1.default.validateModel(request);
|
|
5935
6599
|
let query = {};
|
|
5936
|
-
|
|
5937
|
-
|
|
6600
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6601
|
+
query["DirectoryId"] = request.directoryId;
|
|
6602
|
+
}
|
|
6603
|
+
if (!tea_util_1.default.isUnset(request.MFAAuthenticationStatus)) {
|
|
6604
|
+
query["MFAAuthenticationStatus"] = request.MFAAuthenticationStatus;
|
|
6605
|
+
}
|
|
5938
6606
|
let req = new $OpenApi.OpenApiRequest({
|
|
5939
6607
|
query: openapi_util_1.default.query(query),
|
|
5940
|
-
body: tea_util_1.default.toMap(request),
|
|
5941
6608
|
});
|
|
5942
6609
|
let params = new $OpenApi.Params({
|
|
5943
6610
|
action: "SetMFAAuthenticationStatus",
|
|
@@ -5947,7 +6614,7 @@ class Client extends openapi_client_1.default {
|
|
|
5947
6614
|
method: "POST",
|
|
5948
6615
|
authType: "AK",
|
|
5949
6616
|
style: "RPC",
|
|
5950
|
-
reqBodyType: "
|
|
6617
|
+
reqBodyType: "formData",
|
|
5951
6618
|
bodyType: "json",
|
|
5952
6619
|
});
|
|
5953
6620
|
return $tea.cast(await this.callApi(params, req, runtime), new SetMFAAuthenticationStatusResponse({}));
|
|
@@ -5959,11 +6626,14 @@ class Client extends openapi_client_1.default {
|
|
|
5959
6626
|
async setSCIMSynchronizationStatusWithOptions(request, runtime) {
|
|
5960
6627
|
tea_util_1.default.validateModel(request);
|
|
5961
6628
|
let query = {};
|
|
5962
|
-
|
|
5963
|
-
|
|
6629
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6630
|
+
query["DirectoryId"] = request.directoryId;
|
|
6631
|
+
}
|
|
6632
|
+
if (!tea_util_1.default.isUnset(request.SCIMSynchronizationStatus)) {
|
|
6633
|
+
query["SCIMSynchronizationStatus"] = request.SCIMSynchronizationStatus;
|
|
6634
|
+
}
|
|
5964
6635
|
let req = new $OpenApi.OpenApiRequest({
|
|
5965
6636
|
query: openapi_util_1.default.query(query),
|
|
5966
|
-
body: tea_util_1.default.toMap(request),
|
|
5967
6637
|
});
|
|
5968
6638
|
let params = new $OpenApi.Params({
|
|
5969
6639
|
action: "SetSCIMSynchronizationStatus",
|
|
@@ -5973,7 +6643,7 @@ class Client extends openapi_client_1.default {
|
|
|
5973
6643
|
method: "POST",
|
|
5974
6644
|
authType: "AK",
|
|
5975
6645
|
style: "RPC",
|
|
5976
|
-
reqBodyType: "
|
|
6646
|
+
reqBodyType: "formData",
|
|
5977
6647
|
bodyType: "json",
|
|
5978
6648
|
});
|
|
5979
6649
|
return $tea.cast(await this.callApi(params, req, runtime), new SetSCIMSynchronizationStatusResponse({}));
|
|
@@ -5985,14 +6655,23 @@ class Client extends openapi_client_1.default {
|
|
|
5985
6655
|
async updateAccessConfigurationWithOptions(request, runtime) {
|
|
5986
6656
|
tea_util_1.default.validateModel(request);
|
|
5987
6657
|
let query = {};
|
|
5988
|
-
|
|
5989
|
-
|
|
5990
|
-
|
|
5991
|
-
|
|
5992
|
-
|
|
6658
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6659
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6660
|
+
}
|
|
6661
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6662
|
+
query["DirectoryId"] = request.directoryId;
|
|
6663
|
+
}
|
|
6664
|
+
if (!tea_util_1.default.isUnset(request.newDescription)) {
|
|
6665
|
+
query["NewDescription"] = request.newDescription;
|
|
6666
|
+
}
|
|
6667
|
+
if (!tea_util_1.default.isUnset(request.newRelayState)) {
|
|
6668
|
+
query["NewRelayState"] = request.newRelayState;
|
|
6669
|
+
}
|
|
6670
|
+
if (!tea_util_1.default.isUnset(request.newSessionDuration)) {
|
|
6671
|
+
query["NewSessionDuration"] = request.newSessionDuration;
|
|
6672
|
+
}
|
|
5993
6673
|
let req = new $OpenApi.OpenApiRequest({
|
|
5994
6674
|
query: openapi_util_1.default.query(query),
|
|
5995
|
-
body: tea_util_1.default.toMap(request),
|
|
5996
6675
|
});
|
|
5997
6676
|
let params = new $OpenApi.Params({
|
|
5998
6677
|
action: "UpdateAccessConfiguration",
|
|
@@ -6002,7 +6681,7 @@ class Client extends openapi_client_1.default {
|
|
|
6002
6681
|
method: "POST",
|
|
6003
6682
|
authType: "AK",
|
|
6004
6683
|
style: "RPC",
|
|
6005
|
-
reqBodyType: "
|
|
6684
|
+
reqBodyType: "formData",
|
|
6006
6685
|
bodyType: "json",
|
|
6007
6686
|
});
|
|
6008
6687
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateAccessConfigurationResponse({}));
|
|
@@ -6014,11 +6693,14 @@ class Client extends openapi_client_1.default {
|
|
|
6014
6693
|
async updateDirectoryWithOptions(request, runtime) {
|
|
6015
6694
|
tea_util_1.default.validateModel(request);
|
|
6016
6695
|
let query = {};
|
|
6017
|
-
|
|
6018
|
-
|
|
6696
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6697
|
+
query["DirectoryId"] = request.directoryId;
|
|
6698
|
+
}
|
|
6699
|
+
if (!tea_util_1.default.isUnset(request.newDirectoryName)) {
|
|
6700
|
+
query["NewDirectoryName"] = request.newDirectoryName;
|
|
6701
|
+
}
|
|
6019
6702
|
let req = new $OpenApi.OpenApiRequest({
|
|
6020
6703
|
query: openapi_util_1.default.query(query),
|
|
6021
|
-
body: tea_util_1.default.toMap(request),
|
|
6022
6704
|
});
|
|
6023
6705
|
let params = new $OpenApi.Params({
|
|
6024
6706
|
action: "UpdateDirectory",
|
|
@@ -6028,7 +6710,7 @@ class Client extends openapi_client_1.default {
|
|
|
6028
6710
|
method: "POST",
|
|
6029
6711
|
authType: "AK",
|
|
6030
6712
|
style: "RPC",
|
|
6031
|
-
reqBodyType: "
|
|
6713
|
+
reqBodyType: "formData",
|
|
6032
6714
|
bodyType: "json",
|
|
6033
6715
|
});
|
|
6034
6716
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateDirectoryResponse({}));
|
|
@@ -6040,13 +6722,20 @@ class Client extends openapi_client_1.default {
|
|
|
6040
6722
|
async updateGroupWithOptions(request, runtime) {
|
|
6041
6723
|
tea_util_1.default.validateModel(request);
|
|
6042
6724
|
let query = {};
|
|
6043
|
-
|
|
6044
|
-
|
|
6045
|
-
|
|
6046
|
-
|
|
6725
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6726
|
+
query["DirectoryId"] = request.directoryId;
|
|
6727
|
+
}
|
|
6728
|
+
if (!tea_util_1.default.isUnset(request.groupId)) {
|
|
6729
|
+
query["GroupId"] = request.groupId;
|
|
6730
|
+
}
|
|
6731
|
+
if (!tea_util_1.default.isUnset(request.newDescription)) {
|
|
6732
|
+
query["NewDescription"] = request.newDescription;
|
|
6733
|
+
}
|
|
6734
|
+
if (!tea_util_1.default.isUnset(request.newGroupName)) {
|
|
6735
|
+
query["NewGroupName"] = request.newGroupName;
|
|
6736
|
+
}
|
|
6047
6737
|
let req = new $OpenApi.OpenApiRequest({
|
|
6048
6738
|
query: openapi_util_1.default.query(query),
|
|
6049
|
-
body: tea_util_1.default.toMap(request),
|
|
6050
6739
|
});
|
|
6051
6740
|
let params = new $OpenApi.Params({
|
|
6052
6741
|
action: "UpdateGroup",
|
|
@@ -6056,7 +6745,7 @@ class Client extends openapi_client_1.default {
|
|
|
6056
6745
|
method: "POST",
|
|
6057
6746
|
authType: "AK",
|
|
6058
6747
|
style: "RPC",
|
|
6059
|
-
reqBodyType: "
|
|
6748
|
+
reqBodyType: "formData",
|
|
6060
6749
|
bodyType: "json",
|
|
6061
6750
|
});
|
|
6062
6751
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateGroupResponse({}));
|
|
@@ -6068,13 +6757,20 @@ class Client extends openapi_client_1.default {
|
|
|
6068
6757
|
async updateInlinePolicyForAccessConfigurationWithOptions(request, runtime) {
|
|
6069
6758
|
tea_util_1.default.validateModel(request);
|
|
6070
6759
|
let query = {};
|
|
6071
|
-
|
|
6072
|
-
|
|
6073
|
-
|
|
6074
|
-
|
|
6760
|
+
if (!tea_util_1.default.isUnset(request.accessConfigurationId)) {
|
|
6761
|
+
query["AccessConfigurationId"] = request.accessConfigurationId;
|
|
6762
|
+
}
|
|
6763
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6764
|
+
query["DirectoryId"] = request.directoryId;
|
|
6765
|
+
}
|
|
6766
|
+
if (!tea_util_1.default.isUnset(request.inlinePolicyName)) {
|
|
6767
|
+
query["InlinePolicyName"] = request.inlinePolicyName;
|
|
6768
|
+
}
|
|
6769
|
+
if (!tea_util_1.default.isUnset(request.newInlinePolicyDocument)) {
|
|
6770
|
+
query["NewInlinePolicyDocument"] = request.newInlinePolicyDocument;
|
|
6771
|
+
}
|
|
6075
6772
|
let req = new $OpenApi.OpenApiRequest({
|
|
6076
6773
|
query: openapi_util_1.default.query(query),
|
|
6077
|
-
body: tea_util_1.default.toMap(request),
|
|
6078
6774
|
});
|
|
6079
6775
|
let params = new $OpenApi.Params({
|
|
6080
6776
|
action: "UpdateInlinePolicyForAccessConfiguration",
|
|
@@ -6084,7 +6780,7 @@ class Client extends openapi_client_1.default {
|
|
|
6084
6780
|
method: "POST",
|
|
6085
6781
|
authType: "AK",
|
|
6086
6782
|
style: "RPC",
|
|
6087
|
-
reqBodyType: "
|
|
6783
|
+
reqBodyType: "formData",
|
|
6088
6784
|
bodyType: "json",
|
|
6089
6785
|
});
|
|
6090
6786
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateInlinePolicyForAccessConfigurationResponse({}));
|
|
@@ -6093,15 +6789,52 @@ class Client extends openapi_client_1.default {
|
|
|
6093
6789
|
let runtime = new $Util.RuntimeOptions({});
|
|
6094
6790
|
return await this.updateInlinePolicyForAccessConfigurationWithOptions(request, runtime);
|
|
6095
6791
|
}
|
|
6792
|
+
async updateMFAAuthenticationSettingsWithOptions(request, runtime) {
|
|
6793
|
+
tea_util_1.default.validateModel(request);
|
|
6794
|
+
let query = {};
|
|
6795
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6796
|
+
query["DirectoryId"] = request.directoryId;
|
|
6797
|
+
}
|
|
6798
|
+
if (!tea_util_1.default.isUnset(request.MFAAuthenticationSettings)) {
|
|
6799
|
+
query["MFAAuthenticationSettings"] = request.MFAAuthenticationSettings;
|
|
6800
|
+
}
|
|
6801
|
+
if (!tea_util_1.default.isUnset(request.operationForRiskLogin)) {
|
|
6802
|
+
query["OperationForRiskLogin"] = request.operationForRiskLogin;
|
|
6803
|
+
}
|
|
6804
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6805
|
+
query: openapi_util_1.default.query(query),
|
|
6806
|
+
});
|
|
6807
|
+
let params = new $OpenApi.Params({
|
|
6808
|
+
action: "UpdateMFAAuthenticationSettings",
|
|
6809
|
+
version: "2021-05-15",
|
|
6810
|
+
protocol: "HTTPS",
|
|
6811
|
+
pathname: "/",
|
|
6812
|
+
method: "POST",
|
|
6813
|
+
authType: "AK",
|
|
6814
|
+
style: "RPC",
|
|
6815
|
+
reqBodyType: "formData",
|
|
6816
|
+
bodyType: "json",
|
|
6817
|
+
});
|
|
6818
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateMFAAuthenticationSettingsResponse({}));
|
|
6819
|
+
}
|
|
6820
|
+
async updateMFAAuthenticationSettings(request) {
|
|
6821
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6822
|
+
return await this.updateMFAAuthenticationSettingsWithOptions(request, runtime);
|
|
6823
|
+
}
|
|
6096
6824
|
async updateSCIMServerCredentialStatusWithOptions(request, runtime) {
|
|
6097
6825
|
tea_util_1.default.validateModel(request);
|
|
6098
6826
|
let query = {};
|
|
6099
|
-
|
|
6100
|
-
|
|
6101
|
-
|
|
6827
|
+
if (!tea_util_1.default.isUnset(request.credentialId)) {
|
|
6828
|
+
query["CredentialId"] = request.credentialId;
|
|
6829
|
+
}
|
|
6830
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6831
|
+
query["DirectoryId"] = request.directoryId;
|
|
6832
|
+
}
|
|
6833
|
+
if (!tea_util_1.default.isUnset(request.newStatus)) {
|
|
6834
|
+
query["NewStatus"] = request.newStatus;
|
|
6835
|
+
}
|
|
6102
6836
|
let req = new $OpenApi.OpenApiRequest({
|
|
6103
6837
|
query: openapi_util_1.default.query(query),
|
|
6104
|
-
body: tea_util_1.default.toMap(request),
|
|
6105
6838
|
});
|
|
6106
6839
|
let params = new $OpenApi.Params({
|
|
6107
6840
|
action: "UpdateSCIMServerCredentialStatus",
|
|
@@ -6111,7 +6844,7 @@ class Client extends openapi_client_1.default {
|
|
|
6111
6844
|
method: "POST",
|
|
6112
6845
|
authType: "AK",
|
|
6113
6846
|
style: "RPC",
|
|
6114
|
-
reqBodyType: "
|
|
6847
|
+
reqBodyType: "formData",
|
|
6115
6848
|
bodyType: "json",
|
|
6116
6849
|
});
|
|
6117
6850
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateSCIMServerCredentialStatusResponse({}));
|
|
@@ -6123,16 +6856,29 @@ class Client extends openapi_client_1.default {
|
|
|
6123
6856
|
async updateUserWithOptions(request, runtime) {
|
|
6124
6857
|
tea_util_1.default.validateModel(request);
|
|
6125
6858
|
let query = {};
|
|
6126
|
-
|
|
6127
|
-
|
|
6128
|
-
|
|
6129
|
-
|
|
6130
|
-
|
|
6131
|
-
|
|
6132
|
-
|
|
6859
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6860
|
+
query["DirectoryId"] = request.directoryId;
|
|
6861
|
+
}
|
|
6862
|
+
if (!tea_util_1.default.isUnset(request.newDescription)) {
|
|
6863
|
+
query["NewDescription"] = request.newDescription;
|
|
6864
|
+
}
|
|
6865
|
+
if (!tea_util_1.default.isUnset(request.newDisplayName)) {
|
|
6866
|
+
query["NewDisplayName"] = request.newDisplayName;
|
|
6867
|
+
}
|
|
6868
|
+
if (!tea_util_1.default.isUnset(request.newEmail)) {
|
|
6869
|
+
query["NewEmail"] = request.newEmail;
|
|
6870
|
+
}
|
|
6871
|
+
if (!tea_util_1.default.isUnset(request.newFirstName)) {
|
|
6872
|
+
query["NewFirstName"] = request.newFirstName;
|
|
6873
|
+
}
|
|
6874
|
+
if (!tea_util_1.default.isUnset(request.newLastName)) {
|
|
6875
|
+
query["NewLastName"] = request.newLastName;
|
|
6876
|
+
}
|
|
6877
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6878
|
+
query["UserId"] = request.userId;
|
|
6879
|
+
}
|
|
6133
6880
|
let req = new $OpenApi.OpenApiRequest({
|
|
6134
6881
|
query: openapi_util_1.default.query(query),
|
|
6135
|
-
body: tea_util_1.default.toMap(request),
|
|
6136
6882
|
});
|
|
6137
6883
|
let params = new $OpenApi.Params({
|
|
6138
6884
|
action: "UpdateUser",
|
|
@@ -6142,7 +6888,7 @@ class Client extends openapi_client_1.default {
|
|
|
6142
6888
|
method: "POST",
|
|
6143
6889
|
authType: "AK",
|
|
6144
6890
|
style: "RPC",
|
|
6145
|
-
reqBodyType: "
|
|
6891
|
+
reqBodyType: "formData",
|
|
6146
6892
|
bodyType: "json",
|
|
6147
6893
|
});
|
|
6148
6894
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateUserResponse({}));
|
|
@@ -6151,15 +6897,52 @@ class Client extends openapi_client_1.default {
|
|
|
6151
6897
|
let runtime = new $Util.RuntimeOptions({});
|
|
6152
6898
|
return await this.updateUserWithOptions(request, runtime);
|
|
6153
6899
|
}
|
|
6900
|
+
async updateUserMFAAuthenticationSettingsWithOptions(request, runtime) {
|
|
6901
|
+
tea_util_1.default.validateModel(request);
|
|
6902
|
+
let query = {};
|
|
6903
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6904
|
+
query["DirectoryId"] = request.directoryId;
|
|
6905
|
+
}
|
|
6906
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6907
|
+
query["UserId"] = request.userId;
|
|
6908
|
+
}
|
|
6909
|
+
if (!tea_util_1.default.isUnset(request.userMFAAuthenticationSettings)) {
|
|
6910
|
+
query["UserMFAAuthenticationSettings"] = request.userMFAAuthenticationSettings;
|
|
6911
|
+
}
|
|
6912
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6913
|
+
query: openapi_util_1.default.query(query),
|
|
6914
|
+
});
|
|
6915
|
+
let params = new $OpenApi.Params({
|
|
6916
|
+
action: "UpdateUserMFAAuthenticationSettings",
|
|
6917
|
+
version: "2021-05-15",
|
|
6918
|
+
protocol: "HTTPS",
|
|
6919
|
+
pathname: "/",
|
|
6920
|
+
method: "POST",
|
|
6921
|
+
authType: "AK",
|
|
6922
|
+
style: "RPC",
|
|
6923
|
+
reqBodyType: "formData",
|
|
6924
|
+
bodyType: "json",
|
|
6925
|
+
});
|
|
6926
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateUserMFAAuthenticationSettingsResponse({}));
|
|
6927
|
+
}
|
|
6928
|
+
async updateUserMFAAuthenticationSettings(request) {
|
|
6929
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6930
|
+
return await this.updateUserMFAAuthenticationSettingsWithOptions(request, runtime);
|
|
6931
|
+
}
|
|
6154
6932
|
async updateUserStatusWithOptions(request, runtime) {
|
|
6155
6933
|
tea_util_1.default.validateModel(request);
|
|
6156
6934
|
let query = {};
|
|
6157
|
-
|
|
6158
|
-
|
|
6159
|
-
|
|
6935
|
+
if (!tea_util_1.default.isUnset(request.directoryId)) {
|
|
6936
|
+
query["DirectoryId"] = request.directoryId;
|
|
6937
|
+
}
|
|
6938
|
+
if (!tea_util_1.default.isUnset(request.newStatus)) {
|
|
6939
|
+
query["NewStatus"] = request.newStatus;
|
|
6940
|
+
}
|
|
6941
|
+
if (!tea_util_1.default.isUnset(request.userId)) {
|
|
6942
|
+
query["UserId"] = request.userId;
|
|
6943
|
+
}
|
|
6160
6944
|
let req = new $OpenApi.OpenApiRequest({
|
|
6161
6945
|
query: openapi_util_1.default.query(query),
|
|
6162
|
-
body: tea_util_1.default.toMap(request),
|
|
6163
6946
|
});
|
|
6164
6947
|
let params = new $OpenApi.Params({
|
|
6165
6948
|
action: "UpdateUserStatus",
|
|
@@ -6169,7 +6952,7 @@ class Client extends openapi_client_1.default {
|
|
|
6169
6952
|
method: "POST",
|
|
6170
6953
|
authType: "AK",
|
|
6171
6954
|
style: "RPC",
|
|
6172
|
-
reqBodyType: "
|
|
6955
|
+
reqBodyType: "formData",
|
|
6173
6956
|
bodyType: "json",
|
|
6174
6957
|
});
|
|
6175
6958
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateUserStatusResponse({}));
|