@alicloud/csas20230120 1.1.1 → 1.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client.d.ts +1329 -37
- package/dist/client.js +2925 -613
- package/dist/client.js.map +1 -1
- package/package.json +1 -1
- package/src/client.ts +3290 -337
package/dist/client.js
CHANGED
|
@@ -359,6 +359,116 @@ class CreatePrivateAccessTagResponse extends $tea.Model {
|
|
|
359
359
|
}
|
|
360
360
|
}
|
|
361
361
|
exports.CreatePrivateAccessTagResponse = CreatePrivateAccessTagResponse;
|
|
362
|
+
class CreateRegistrationPolicyRequest extends $tea.Model {
|
|
363
|
+
constructor(map) {
|
|
364
|
+
super(map);
|
|
365
|
+
}
|
|
366
|
+
static names() {
|
|
367
|
+
return {
|
|
368
|
+
companyLimitCount: 'CompanyLimitCount',
|
|
369
|
+
companyLimitType: 'CompanyLimitType',
|
|
370
|
+
description: 'Description',
|
|
371
|
+
matchMode: 'MatchMode',
|
|
372
|
+
name: 'Name',
|
|
373
|
+
personalLimitCount: 'PersonalLimitCount',
|
|
374
|
+
personalLimitType: 'PersonalLimitType',
|
|
375
|
+
priority: 'Priority',
|
|
376
|
+
status: 'Status',
|
|
377
|
+
userGroupIds: 'UserGroupIds',
|
|
378
|
+
whitelist: 'Whitelist',
|
|
379
|
+
};
|
|
380
|
+
}
|
|
381
|
+
static types() {
|
|
382
|
+
return {
|
|
383
|
+
companyLimitCount: CreateRegistrationPolicyRequestCompanyLimitCount,
|
|
384
|
+
companyLimitType: 'string',
|
|
385
|
+
description: 'string',
|
|
386
|
+
matchMode: 'string',
|
|
387
|
+
name: 'string',
|
|
388
|
+
personalLimitCount: CreateRegistrationPolicyRequestPersonalLimitCount,
|
|
389
|
+
personalLimitType: 'string',
|
|
390
|
+
priority: 'number',
|
|
391
|
+
status: 'string',
|
|
392
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
393
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
394
|
+
};
|
|
395
|
+
}
|
|
396
|
+
}
|
|
397
|
+
exports.CreateRegistrationPolicyRequest = CreateRegistrationPolicyRequest;
|
|
398
|
+
class CreateRegistrationPolicyShrinkRequest extends $tea.Model {
|
|
399
|
+
constructor(map) {
|
|
400
|
+
super(map);
|
|
401
|
+
}
|
|
402
|
+
static names() {
|
|
403
|
+
return {
|
|
404
|
+
companyLimitCountShrink: 'CompanyLimitCount',
|
|
405
|
+
companyLimitType: 'CompanyLimitType',
|
|
406
|
+
description: 'Description',
|
|
407
|
+
matchMode: 'MatchMode',
|
|
408
|
+
name: 'Name',
|
|
409
|
+
personalLimitCountShrink: 'PersonalLimitCount',
|
|
410
|
+
personalLimitType: 'PersonalLimitType',
|
|
411
|
+
priority: 'Priority',
|
|
412
|
+
status: 'Status',
|
|
413
|
+
userGroupIds: 'UserGroupIds',
|
|
414
|
+
whitelist: 'Whitelist',
|
|
415
|
+
};
|
|
416
|
+
}
|
|
417
|
+
static types() {
|
|
418
|
+
return {
|
|
419
|
+
companyLimitCountShrink: 'string',
|
|
420
|
+
companyLimitType: 'string',
|
|
421
|
+
description: 'string',
|
|
422
|
+
matchMode: 'string',
|
|
423
|
+
name: 'string',
|
|
424
|
+
personalLimitCountShrink: 'string',
|
|
425
|
+
personalLimitType: 'string',
|
|
426
|
+
priority: 'number',
|
|
427
|
+
status: 'string',
|
|
428
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
429
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
430
|
+
};
|
|
431
|
+
}
|
|
432
|
+
}
|
|
433
|
+
exports.CreateRegistrationPolicyShrinkRequest = CreateRegistrationPolicyShrinkRequest;
|
|
434
|
+
class CreateRegistrationPolicyResponseBody extends $tea.Model {
|
|
435
|
+
constructor(map) {
|
|
436
|
+
super(map);
|
|
437
|
+
}
|
|
438
|
+
static names() {
|
|
439
|
+
return {
|
|
440
|
+
policy: 'Policy',
|
|
441
|
+
requestId: 'RequestId',
|
|
442
|
+
};
|
|
443
|
+
}
|
|
444
|
+
static types() {
|
|
445
|
+
return {
|
|
446
|
+
policy: CreateRegistrationPolicyResponseBodyPolicy,
|
|
447
|
+
requestId: 'string',
|
|
448
|
+
};
|
|
449
|
+
}
|
|
450
|
+
}
|
|
451
|
+
exports.CreateRegistrationPolicyResponseBody = CreateRegistrationPolicyResponseBody;
|
|
452
|
+
class CreateRegistrationPolicyResponse extends $tea.Model {
|
|
453
|
+
constructor(map) {
|
|
454
|
+
super(map);
|
|
455
|
+
}
|
|
456
|
+
static names() {
|
|
457
|
+
return {
|
|
458
|
+
headers: 'headers',
|
|
459
|
+
statusCode: 'statusCode',
|
|
460
|
+
body: 'body',
|
|
461
|
+
};
|
|
462
|
+
}
|
|
463
|
+
static types() {
|
|
464
|
+
return {
|
|
465
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
466
|
+
statusCode: 'number',
|
|
467
|
+
body: CreateRegistrationPolicyResponseBody,
|
|
468
|
+
};
|
|
469
|
+
}
|
|
470
|
+
}
|
|
471
|
+
exports.CreateRegistrationPolicyResponse = CreateRegistrationPolicyResponse;
|
|
362
472
|
class CreateUserGroupRequest extends $tea.Model {
|
|
363
473
|
constructor(map) {
|
|
364
474
|
super(map);
|
|
@@ -625,6 +735,58 @@ class DeletePrivateAccessTagResponse extends $tea.Model {
|
|
|
625
735
|
}
|
|
626
736
|
}
|
|
627
737
|
exports.DeletePrivateAccessTagResponse = DeletePrivateAccessTagResponse;
|
|
738
|
+
class DeleteRegistrationPoliciesRequest extends $tea.Model {
|
|
739
|
+
constructor(map) {
|
|
740
|
+
super(map);
|
|
741
|
+
}
|
|
742
|
+
static names() {
|
|
743
|
+
return {
|
|
744
|
+
policyIds: 'PolicyIds',
|
|
745
|
+
};
|
|
746
|
+
}
|
|
747
|
+
static types() {
|
|
748
|
+
return {
|
|
749
|
+
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
750
|
+
};
|
|
751
|
+
}
|
|
752
|
+
}
|
|
753
|
+
exports.DeleteRegistrationPoliciesRequest = DeleteRegistrationPoliciesRequest;
|
|
754
|
+
class DeleteRegistrationPoliciesResponseBody extends $tea.Model {
|
|
755
|
+
constructor(map) {
|
|
756
|
+
super(map);
|
|
757
|
+
}
|
|
758
|
+
static names() {
|
|
759
|
+
return {
|
|
760
|
+
requestId: 'RequestId',
|
|
761
|
+
};
|
|
762
|
+
}
|
|
763
|
+
static types() {
|
|
764
|
+
return {
|
|
765
|
+
requestId: 'string',
|
|
766
|
+
};
|
|
767
|
+
}
|
|
768
|
+
}
|
|
769
|
+
exports.DeleteRegistrationPoliciesResponseBody = DeleteRegistrationPoliciesResponseBody;
|
|
770
|
+
class DeleteRegistrationPoliciesResponse extends $tea.Model {
|
|
771
|
+
constructor(map) {
|
|
772
|
+
super(map);
|
|
773
|
+
}
|
|
774
|
+
static names() {
|
|
775
|
+
return {
|
|
776
|
+
headers: 'headers',
|
|
777
|
+
statusCode: 'statusCode',
|
|
778
|
+
body: 'body',
|
|
779
|
+
};
|
|
780
|
+
}
|
|
781
|
+
static types() {
|
|
782
|
+
return {
|
|
783
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
784
|
+
statusCode: 'number',
|
|
785
|
+
body: DeleteRegistrationPoliciesResponseBody,
|
|
786
|
+
};
|
|
787
|
+
}
|
|
788
|
+
}
|
|
789
|
+
exports.DeleteRegistrationPoliciesResponse = DeleteRegistrationPoliciesResponse;
|
|
628
790
|
class DeleteUserGroupRequest extends $tea.Model {
|
|
629
791
|
constructor(map) {
|
|
630
792
|
super(map);
|
|
@@ -911,6 +1073,132 @@ class GetPrivateAccessPolicyResponse extends $tea.Model {
|
|
|
911
1073
|
}
|
|
912
1074
|
}
|
|
913
1075
|
exports.GetPrivateAccessPolicyResponse = GetPrivateAccessPolicyResponse;
|
|
1076
|
+
class GetRegistrationPolicyRequest extends $tea.Model {
|
|
1077
|
+
constructor(map) {
|
|
1078
|
+
super(map);
|
|
1079
|
+
}
|
|
1080
|
+
static names() {
|
|
1081
|
+
return {
|
|
1082
|
+
policyId: 'PolicyId',
|
|
1083
|
+
};
|
|
1084
|
+
}
|
|
1085
|
+
static types() {
|
|
1086
|
+
return {
|
|
1087
|
+
policyId: 'string',
|
|
1088
|
+
};
|
|
1089
|
+
}
|
|
1090
|
+
}
|
|
1091
|
+
exports.GetRegistrationPolicyRequest = GetRegistrationPolicyRequest;
|
|
1092
|
+
class GetRegistrationPolicyResponseBody extends $tea.Model {
|
|
1093
|
+
constructor(map) {
|
|
1094
|
+
super(map);
|
|
1095
|
+
}
|
|
1096
|
+
static names() {
|
|
1097
|
+
return {
|
|
1098
|
+
createTime: 'CreateTime',
|
|
1099
|
+
description: 'Description',
|
|
1100
|
+
limitDetail: 'LimitDetail',
|
|
1101
|
+
matchMode: 'MatchMode',
|
|
1102
|
+
name: 'Name',
|
|
1103
|
+
policyId: 'PolicyId',
|
|
1104
|
+
priority: 'Priority',
|
|
1105
|
+
requestId: 'RequestId',
|
|
1106
|
+
status: 'Status',
|
|
1107
|
+
userGroupIds: 'UserGroupIds',
|
|
1108
|
+
whitelist: 'Whitelist',
|
|
1109
|
+
};
|
|
1110
|
+
}
|
|
1111
|
+
static types() {
|
|
1112
|
+
return {
|
|
1113
|
+
createTime: 'string',
|
|
1114
|
+
description: 'string',
|
|
1115
|
+
limitDetail: { 'type': 'array', 'itemType': GetRegistrationPolicyResponseBodyLimitDetail },
|
|
1116
|
+
matchMode: 'string',
|
|
1117
|
+
name: 'string',
|
|
1118
|
+
policyId: 'string',
|
|
1119
|
+
priority: 'number',
|
|
1120
|
+
requestId: 'string',
|
|
1121
|
+
status: 'string',
|
|
1122
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
1123
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
1124
|
+
};
|
|
1125
|
+
}
|
|
1126
|
+
}
|
|
1127
|
+
exports.GetRegistrationPolicyResponseBody = GetRegistrationPolicyResponseBody;
|
|
1128
|
+
class GetRegistrationPolicyResponse extends $tea.Model {
|
|
1129
|
+
constructor(map) {
|
|
1130
|
+
super(map);
|
|
1131
|
+
}
|
|
1132
|
+
static names() {
|
|
1133
|
+
return {
|
|
1134
|
+
headers: 'headers',
|
|
1135
|
+
statusCode: 'statusCode',
|
|
1136
|
+
body: 'body',
|
|
1137
|
+
};
|
|
1138
|
+
}
|
|
1139
|
+
static types() {
|
|
1140
|
+
return {
|
|
1141
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1142
|
+
statusCode: 'number',
|
|
1143
|
+
body: GetRegistrationPolicyResponseBody,
|
|
1144
|
+
};
|
|
1145
|
+
}
|
|
1146
|
+
}
|
|
1147
|
+
exports.GetRegistrationPolicyResponse = GetRegistrationPolicyResponse;
|
|
1148
|
+
class GetUserDeviceRequest extends $tea.Model {
|
|
1149
|
+
constructor(map) {
|
|
1150
|
+
super(map);
|
|
1151
|
+
}
|
|
1152
|
+
static names() {
|
|
1153
|
+
return {
|
|
1154
|
+
deviceTag: 'DeviceTag',
|
|
1155
|
+
};
|
|
1156
|
+
}
|
|
1157
|
+
static types() {
|
|
1158
|
+
return {
|
|
1159
|
+
deviceTag: 'string',
|
|
1160
|
+
};
|
|
1161
|
+
}
|
|
1162
|
+
}
|
|
1163
|
+
exports.GetUserDeviceRequest = GetUserDeviceRequest;
|
|
1164
|
+
class GetUserDeviceResponseBody extends $tea.Model {
|
|
1165
|
+
constructor(map) {
|
|
1166
|
+
super(map);
|
|
1167
|
+
}
|
|
1168
|
+
static names() {
|
|
1169
|
+
return {
|
|
1170
|
+
device: 'Device',
|
|
1171
|
+
requestId: 'RequestId',
|
|
1172
|
+
};
|
|
1173
|
+
}
|
|
1174
|
+
static types() {
|
|
1175
|
+
return {
|
|
1176
|
+
device: GetUserDeviceResponseBodyDevice,
|
|
1177
|
+
requestId: 'string',
|
|
1178
|
+
};
|
|
1179
|
+
}
|
|
1180
|
+
}
|
|
1181
|
+
exports.GetUserDeviceResponseBody = GetUserDeviceResponseBody;
|
|
1182
|
+
class GetUserDeviceResponse extends $tea.Model {
|
|
1183
|
+
constructor(map) {
|
|
1184
|
+
super(map);
|
|
1185
|
+
}
|
|
1186
|
+
static names() {
|
|
1187
|
+
return {
|
|
1188
|
+
headers: 'headers',
|
|
1189
|
+
statusCode: 'statusCode',
|
|
1190
|
+
body: 'body',
|
|
1191
|
+
};
|
|
1192
|
+
}
|
|
1193
|
+
static types() {
|
|
1194
|
+
return {
|
|
1195
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1196
|
+
statusCode: 'number',
|
|
1197
|
+
body: GetUserDeviceResponseBody,
|
|
1198
|
+
};
|
|
1199
|
+
}
|
|
1200
|
+
}
|
|
1201
|
+
exports.GetUserDeviceResponse = GetUserDeviceResponse;
|
|
914
1202
|
class GetUserGroupRequest extends $tea.Model {
|
|
915
1203
|
constructor(map) {
|
|
916
1204
|
super(map);
|
|
@@ -1251,23 +1539,41 @@ class ListDynamicRoutesResponse extends $tea.Model {
|
|
|
1251
1539
|
}
|
|
1252
1540
|
}
|
|
1253
1541
|
exports.ListDynamicRoutesResponse = ListDynamicRoutesResponse;
|
|
1254
|
-
class
|
|
1542
|
+
class ListExcessiveDeviceRegistrationApplicationsRequest extends $tea.Model {
|
|
1255
1543
|
constructor(map) {
|
|
1256
1544
|
super(map);
|
|
1257
1545
|
}
|
|
1258
1546
|
static names() {
|
|
1259
1547
|
return {
|
|
1260
1548
|
applicationIds: 'ApplicationIds',
|
|
1549
|
+
currentPage: 'CurrentPage',
|
|
1550
|
+
department: 'Department',
|
|
1551
|
+
deviceTag: 'DeviceTag',
|
|
1552
|
+
hostname: 'Hostname',
|
|
1553
|
+
mac: 'Mac',
|
|
1554
|
+
pageSize: 'PageSize',
|
|
1555
|
+
saseUserId: 'SaseUserId',
|
|
1556
|
+
statuses: 'Statuses',
|
|
1557
|
+
username: 'Username',
|
|
1261
1558
|
};
|
|
1262
1559
|
}
|
|
1263
1560
|
static types() {
|
|
1264
1561
|
return {
|
|
1265
1562
|
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
1563
|
+
currentPage: 'number',
|
|
1564
|
+
department: 'string',
|
|
1565
|
+
deviceTag: 'string',
|
|
1566
|
+
hostname: 'string',
|
|
1567
|
+
mac: 'string',
|
|
1568
|
+
pageSize: 'number',
|
|
1569
|
+
saseUserId: 'string',
|
|
1570
|
+
statuses: { 'type': 'array', 'itemType': 'string' },
|
|
1571
|
+
username: 'string',
|
|
1266
1572
|
};
|
|
1267
1573
|
}
|
|
1268
1574
|
}
|
|
1269
|
-
exports.
|
|
1270
|
-
class
|
|
1575
|
+
exports.ListExcessiveDeviceRegistrationApplicationsRequest = ListExcessiveDeviceRegistrationApplicationsRequest;
|
|
1576
|
+
class ListExcessiveDeviceRegistrationApplicationsResponseBody extends $tea.Model {
|
|
1271
1577
|
constructor(map) {
|
|
1272
1578
|
super(map);
|
|
1273
1579
|
}
|
|
@@ -1275,17 +1581,19 @@ class ListPolicesForPrivateAccessApplicationResponseBody extends $tea.Model {
|
|
|
1275
1581
|
return {
|
|
1276
1582
|
applications: 'Applications',
|
|
1277
1583
|
requestId: 'RequestId',
|
|
1584
|
+
totalNum: 'TotalNum',
|
|
1278
1585
|
};
|
|
1279
1586
|
}
|
|
1280
1587
|
static types() {
|
|
1281
1588
|
return {
|
|
1282
|
-
applications: { 'type': 'array', 'itemType':
|
|
1589
|
+
applications: { 'type': 'array', 'itemType': ListExcessiveDeviceRegistrationApplicationsResponseBodyApplications },
|
|
1283
1590
|
requestId: 'string',
|
|
1591
|
+
totalNum: 'number',
|
|
1284
1592
|
};
|
|
1285
1593
|
}
|
|
1286
1594
|
}
|
|
1287
|
-
exports.
|
|
1288
|
-
class
|
|
1595
|
+
exports.ListExcessiveDeviceRegistrationApplicationsResponseBody = ListExcessiveDeviceRegistrationApplicationsResponseBody;
|
|
1596
|
+
class ListExcessiveDeviceRegistrationApplicationsResponse extends $tea.Model {
|
|
1289
1597
|
constructor(map) {
|
|
1290
1598
|
super(map);
|
|
1291
1599
|
}
|
|
@@ -1300,46 +1608,46 @@ class ListPolicesForPrivateAccessApplicationResponse extends $tea.Model {
|
|
|
1300
1608
|
return {
|
|
1301
1609
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1302
1610
|
statusCode: 'number',
|
|
1303
|
-
body:
|
|
1611
|
+
body: ListExcessiveDeviceRegistrationApplicationsResponseBody,
|
|
1304
1612
|
};
|
|
1305
1613
|
}
|
|
1306
1614
|
}
|
|
1307
|
-
exports.
|
|
1308
|
-
class
|
|
1615
|
+
exports.ListExcessiveDeviceRegistrationApplicationsResponse = ListExcessiveDeviceRegistrationApplicationsResponse;
|
|
1616
|
+
class ListPolicesForPrivateAccessApplicationRequest extends $tea.Model {
|
|
1309
1617
|
constructor(map) {
|
|
1310
1618
|
super(map);
|
|
1311
1619
|
}
|
|
1312
1620
|
static names() {
|
|
1313
1621
|
return {
|
|
1314
|
-
|
|
1622
|
+
applicationIds: 'ApplicationIds',
|
|
1315
1623
|
};
|
|
1316
1624
|
}
|
|
1317
1625
|
static types() {
|
|
1318
1626
|
return {
|
|
1319
|
-
|
|
1627
|
+
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
1320
1628
|
};
|
|
1321
1629
|
}
|
|
1322
1630
|
}
|
|
1323
|
-
exports.
|
|
1324
|
-
class
|
|
1631
|
+
exports.ListPolicesForPrivateAccessApplicationRequest = ListPolicesForPrivateAccessApplicationRequest;
|
|
1632
|
+
class ListPolicesForPrivateAccessApplicationResponseBody extends $tea.Model {
|
|
1325
1633
|
constructor(map) {
|
|
1326
1634
|
super(map);
|
|
1327
1635
|
}
|
|
1328
1636
|
static names() {
|
|
1329
1637
|
return {
|
|
1638
|
+
applications: 'Applications',
|
|
1330
1639
|
requestId: 'RequestId',
|
|
1331
|
-
tags: 'Tags',
|
|
1332
1640
|
};
|
|
1333
1641
|
}
|
|
1334
1642
|
static types() {
|
|
1335
1643
|
return {
|
|
1644
|
+
applications: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessApplicationResponseBodyApplications },
|
|
1336
1645
|
requestId: 'string',
|
|
1337
|
-
tags: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessTagResponseBodyTags },
|
|
1338
1646
|
};
|
|
1339
1647
|
}
|
|
1340
1648
|
}
|
|
1341
|
-
exports.
|
|
1342
|
-
class
|
|
1649
|
+
exports.ListPolicesForPrivateAccessApplicationResponseBody = ListPolicesForPrivateAccessApplicationResponseBody;
|
|
1650
|
+
class ListPolicesForPrivateAccessApplicationResponse extends $tea.Model {
|
|
1343
1651
|
constructor(map) {
|
|
1344
1652
|
super(map);
|
|
1345
1653
|
}
|
|
@@ -1354,7 +1662,61 @@ class ListPolicesForPrivateAccessTagResponse extends $tea.Model {
|
|
|
1354
1662
|
return {
|
|
1355
1663
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1356
1664
|
statusCode: 'number',
|
|
1357
|
-
body:
|
|
1665
|
+
body: ListPolicesForPrivateAccessApplicationResponseBody,
|
|
1666
|
+
};
|
|
1667
|
+
}
|
|
1668
|
+
}
|
|
1669
|
+
exports.ListPolicesForPrivateAccessApplicationResponse = ListPolicesForPrivateAccessApplicationResponse;
|
|
1670
|
+
class ListPolicesForPrivateAccessTagRequest extends $tea.Model {
|
|
1671
|
+
constructor(map) {
|
|
1672
|
+
super(map);
|
|
1673
|
+
}
|
|
1674
|
+
static names() {
|
|
1675
|
+
return {
|
|
1676
|
+
tagIds: 'TagIds',
|
|
1677
|
+
};
|
|
1678
|
+
}
|
|
1679
|
+
static types() {
|
|
1680
|
+
return {
|
|
1681
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
1682
|
+
};
|
|
1683
|
+
}
|
|
1684
|
+
}
|
|
1685
|
+
exports.ListPolicesForPrivateAccessTagRequest = ListPolicesForPrivateAccessTagRequest;
|
|
1686
|
+
class ListPolicesForPrivateAccessTagResponseBody extends $tea.Model {
|
|
1687
|
+
constructor(map) {
|
|
1688
|
+
super(map);
|
|
1689
|
+
}
|
|
1690
|
+
static names() {
|
|
1691
|
+
return {
|
|
1692
|
+
requestId: 'RequestId',
|
|
1693
|
+
tags: 'Tags',
|
|
1694
|
+
};
|
|
1695
|
+
}
|
|
1696
|
+
static types() {
|
|
1697
|
+
return {
|
|
1698
|
+
requestId: 'string',
|
|
1699
|
+
tags: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessTagResponseBodyTags },
|
|
1700
|
+
};
|
|
1701
|
+
}
|
|
1702
|
+
}
|
|
1703
|
+
exports.ListPolicesForPrivateAccessTagResponseBody = ListPolicesForPrivateAccessTagResponseBody;
|
|
1704
|
+
class ListPolicesForPrivateAccessTagResponse extends $tea.Model {
|
|
1705
|
+
constructor(map) {
|
|
1706
|
+
super(map);
|
|
1707
|
+
}
|
|
1708
|
+
static names() {
|
|
1709
|
+
return {
|
|
1710
|
+
headers: 'headers',
|
|
1711
|
+
statusCode: 'statusCode',
|
|
1712
|
+
body: 'body',
|
|
1713
|
+
};
|
|
1714
|
+
}
|
|
1715
|
+
static types() {
|
|
1716
|
+
return {
|
|
1717
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1718
|
+
statusCode: 'number',
|
|
1719
|
+
body: ListPolicesForPrivateAccessTagResponseBody,
|
|
1358
1720
|
};
|
|
1359
1721
|
}
|
|
1360
1722
|
}
|
|
@@ -1421,6 +1783,7 @@ class ListPrivateAccessApplicationsRequest extends $tea.Model {
|
|
|
1421
1783
|
return {
|
|
1422
1784
|
address: 'Address',
|
|
1423
1785
|
applicationIds: 'ApplicationIds',
|
|
1786
|
+
connectorId: 'ConnectorId',
|
|
1424
1787
|
currentPage: 'CurrentPage',
|
|
1425
1788
|
name: 'Name',
|
|
1426
1789
|
pageSize: 'PageSize',
|
|
@@ -1433,6 +1796,7 @@ class ListPrivateAccessApplicationsRequest extends $tea.Model {
|
|
|
1433
1796
|
return {
|
|
1434
1797
|
address: 'string',
|
|
1435
1798
|
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
1799
|
+
connectorId: 'string',
|
|
1436
1800
|
currentPage: 'number',
|
|
1437
1801
|
name: 'string',
|
|
1438
1802
|
pageSize: 'number',
|
|
@@ -1729,41 +2093,59 @@ class ListPrivateAccessTagsForDynamicRouteResponse extends $tea.Model {
|
|
|
1729
2093
|
}
|
|
1730
2094
|
}
|
|
1731
2095
|
exports.ListPrivateAccessTagsForDynamicRouteResponse = ListPrivateAccessTagsForDynamicRouteResponse;
|
|
1732
|
-
class
|
|
2096
|
+
class ListRegistrationPoliciesRequest extends $tea.Model {
|
|
1733
2097
|
constructor(map) {
|
|
1734
2098
|
super(map);
|
|
1735
2099
|
}
|
|
1736
2100
|
static names() {
|
|
1737
2101
|
return {
|
|
1738
|
-
|
|
2102
|
+
companyLimitType: 'CompanyLimitType',
|
|
2103
|
+
currentPage: 'CurrentPage',
|
|
2104
|
+
matchMode: 'MatchMode',
|
|
2105
|
+
name: 'Name',
|
|
2106
|
+
pageSize: 'PageSize',
|
|
2107
|
+
personalLimitType: 'PersonalLimitType',
|
|
2108
|
+
policyIds: 'PolicyIds',
|
|
2109
|
+
status: 'Status',
|
|
2110
|
+
userGroupId: 'UserGroupId',
|
|
1739
2111
|
};
|
|
1740
2112
|
}
|
|
1741
2113
|
static types() {
|
|
1742
2114
|
return {
|
|
1743
|
-
|
|
2115
|
+
companyLimitType: 'string',
|
|
2116
|
+
currentPage: 'number',
|
|
2117
|
+
matchMode: 'string',
|
|
2118
|
+
name: 'string',
|
|
2119
|
+
pageSize: 'number',
|
|
2120
|
+
personalLimitType: 'string',
|
|
2121
|
+
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
2122
|
+
status: 'string',
|
|
2123
|
+
userGroupId: 'string',
|
|
1744
2124
|
};
|
|
1745
2125
|
}
|
|
1746
2126
|
}
|
|
1747
|
-
exports.
|
|
1748
|
-
class
|
|
2127
|
+
exports.ListRegistrationPoliciesRequest = ListRegistrationPoliciesRequest;
|
|
2128
|
+
class ListRegistrationPoliciesResponseBody extends $tea.Model {
|
|
1749
2129
|
constructor(map) {
|
|
1750
2130
|
super(map);
|
|
1751
2131
|
}
|
|
1752
2132
|
static names() {
|
|
1753
2133
|
return {
|
|
1754
|
-
|
|
2134
|
+
policies: 'Policies',
|
|
1755
2135
|
requestId: 'RequestId',
|
|
2136
|
+
totalNum: 'TotalNum',
|
|
1756
2137
|
};
|
|
1757
2138
|
}
|
|
1758
2139
|
static types() {
|
|
1759
2140
|
return {
|
|
1760
|
-
|
|
2141
|
+
policies: { 'type': 'array', 'itemType': ListRegistrationPoliciesResponseBodyPolicies },
|
|
1761
2142
|
requestId: 'string',
|
|
2143
|
+
totalNum: 'string',
|
|
1762
2144
|
};
|
|
1763
2145
|
}
|
|
1764
2146
|
}
|
|
1765
|
-
exports.
|
|
1766
|
-
class
|
|
2147
|
+
exports.ListRegistrationPoliciesResponseBody = ListRegistrationPoliciesResponseBody;
|
|
2148
|
+
class ListRegistrationPoliciesResponse extends $tea.Model {
|
|
1767
2149
|
constructor(map) {
|
|
1768
2150
|
super(map);
|
|
1769
2151
|
}
|
|
@@ -1778,46 +2160,46 @@ class ListTagsForPrivateAccessApplicationResponse extends $tea.Model {
|
|
|
1778
2160
|
return {
|
|
1779
2161
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1780
2162
|
statusCode: 'number',
|
|
1781
|
-
body:
|
|
2163
|
+
body: ListRegistrationPoliciesResponseBody,
|
|
1782
2164
|
};
|
|
1783
2165
|
}
|
|
1784
2166
|
}
|
|
1785
|
-
exports.
|
|
1786
|
-
class
|
|
2167
|
+
exports.ListRegistrationPoliciesResponse = ListRegistrationPoliciesResponse;
|
|
2168
|
+
class ListRegistrationPoliciesForUserGroupRequest extends $tea.Model {
|
|
1787
2169
|
constructor(map) {
|
|
1788
2170
|
super(map);
|
|
1789
2171
|
}
|
|
1790
2172
|
static names() {
|
|
1791
2173
|
return {
|
|
1792
|
-
|
|
2174
|
+
userGroupIds: 'UserGroupIds',
|
|
1793
2175
|
};
|
|
1794
2176
|
}
|
|
1795
2177
|
static types() {
|
|
1796
2178
|
return {
|
|
1797
|
-
|
|
2179
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
1798
2180
|
};
|
|
1799
2181
|
}
|
|
1800
2182
|
}
|
|
1801
|
-
exports.
|
|
1802
|
-
class
|
|
2183
|
+
exports.ListRegistrationPoliciesForUserGroupRequest = ListRegistrationPoliciesForUserGroupRequest;
|
|
2184
|
+
class ListRegistrationPoliciesForUserGroupResponseBody extends $tea.Model {
|
|
1803
2185
|
constructor(map) {
|
|
1804
2186
|
super(map);
|
|
1805
2187
|
}
|
|
1806
2188
|
static names() {
|
|
1807
2189
|
return {
|
|
1808
|
-
polices: 'Polices',
|
|
1809
2190
|
requestId: 'RequestId',
|
|
2191
|
+
userGroups: 'UserGroups',
|
|
1810
2192
|
};
|
|
1811
2193
|
}
|
|
1812
2194
|
static types() {
|
|
1813
2195
|
return {
|
|
1814
|
-
polices: { 'type': 'array', 'itemType': ListTagsForPrivateAccessPolicyResponseBodyPolices },
|
|
1815
2196
|
requestId: 'string',
|
|
2197
|
+
userGroups: { 'type': 'array', 'itemType': ListRegistrationPoliciesForUserGroupResponseBodyUserGroups },
|
|
1816
2198
|
};
|
|
1817
2199
|
}
|
|
1818
2200
|
}
|
|
1819
|
-
exports.
|
|
1820
|
-
class
|
|
2201
|
+
exports.ListRegistrationPoliciesForUserGroupResponseBody = ListRegistrationPoliciesForUserGroupResponseBody;
|
|
2202
|
+
class ListRegistrationPoliciesForUserGroupResponse extends $tea.Model {
|
|
1821
2203
|
constructor(map) {
|
|
1822
2204
|
super(map);
|
|
1823
2205
|
}
|
|
@@ -1832,58 +2214,52 @@ class ListTagsForPrivateAccessPolicyResponse extends $tea.Model {
|
|
|
1832
2214
|
return {
|
|
1833
2215
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1834
2216
|
statusCode: 'number',
|
|
1835
|
-
body:
|
|
2217
|
+
body: ListRegistrationPoliciesForUserGroupResponseBody,
|
|
1836
2218
|
};
|
|
1837
2219
|
}
|
|
1838
2220
|
}
|
|
1839
|
-
exports.
|
|
1840
|
-
class
|
|
2221
|
+
exports.ListRegistrationPoliciesForUserGroupResponse = ListRegistrationPoliciesForUserGroupResponse;
|
|
2222
|
+
class ListSoftwareForUserDeviceRequest extends $tea.Model {
|
|
1841
2223
|
constructor(map) {
|
|
1842
2224
|
super(map);
|
|
1843
2225
|
}
|
|
1844
2226
|
static names() {
|
|
1845
2227
|
return {
|
|
1846
|
-
attributeValue: 'AttributeValue',
|
|
1847
2228
|
currentPage: 'CurrentPage',
|
|
1848
|
-
|
|
1849
|
-
PAPolicyId: 'PAPolicyId',
|
|
2229
|
+
deviceTag: 'DeviceTag',
|
|
1850
2230
|
pageSize: 'PageSize',
|
|
1851
|
-
userGroupIds: 'UserGroupIds',
|
|
1852
2231
|
};
|
|
1853
2232
|
}
|
|
1854
2233
|
static types() {
|
|
1855
2234
|
return {
|
|
1856
|
-
attributeValue: 'string',
|
|
1857
2235
|
currentPage: 'number',
|
|
1858
|
-
|
|
1859
|
-
PAPolicyId: 'string',
|
|
2236
|
+
deviceTag: 'string',
|
|
1860
2237
|
pageSize: 'number',
|
|
1861
|
-
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
1862
2238
|
};
|
|
1863
2239
|
}
|
|
1864
2240
|
}
|
|
1865
|
-
exports.
|
|
1866
|
-
class
|
|
2241
|
+
exports.ListSoftwareForUserDeviceRequest = ListSoftwareForUserDeviceRequest;
|
|
2242
|
+
class ListSoftwareForUserDeviceResponseBody extends $tea.Model {
|
|
1867
2243
|
constructor(map) {
|
|
1868
2244
|
super(map);
|
|
1869
2245
|
}
|
|
1870
2246
|
static names() {
|
|
1871
2247
|
return {
|
|
1872
2248
|
requestId: 'RequestId',
|
|
2249
|
+
software: 'Software',
|
|
1873
2250
|
totalNum: 'TotalNum',
|
|
1874
|
-
userGroups: 'UserGroups',
|
|
1875
2251
|
};
|
|
1876
2252
|
}
|
|
1877
2253
|
static types() {
|
|
1878
2254
|
return {
|
|
1879
2255
|
requestId: 'string',
|
|
2256
|
+
software: { 'type': 'array', 'itemType': ListSoftwareForUserDeviceResponseBodySoftware },
|
|
1880
2257
|
totalNum: 'number',
|
|
1881
|
-
userGroups: { 'type': 'array', 'itemType': ListUserGroupsResponseBodyUserGroups },
|
|
1882
2258
|
};
|
|
1883
2259
|
}
|
|
1884
2260
|
}
|
|
1885
|
-
exports.
|
|
1886
|
-
class
|
|
2261
|
+
exports.ListSoftwareForUserDeviceResponseBody = ListSoftwareForUserDeviceResponseBody;
|
|
2262
|
+
class ListSoftwareForUserDeviceResponse extends $tea.Model {
|
|
1887
2263
|
constructor(map) {
|
|
1888
2264
|
super(map);
|
|
1889
2265
|
}
|
|
@@ -1898,46 +2274,46 @@ class ListUserGroupsResponse extends $tea.Model {
|
|
|
1898
2274
|
return {
|
|
1899
2275
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1900
2276
|
statusCode: 'number',
|
|
1901
|
-
body:
|
|
2277
|
+
body: ListSoftwareForUserDeviceResponseBody,
|
|
1902
2278
|
};
|
|
1903
2279
|
}
|
|
1904
2280
|
}
|
|
1905
|
-
exports.
|
|
1906
|
-
class
|
|
2281
|
+
exports.ListSoftwareForUserDeviceResponse = ListSoftwareForUserDeviceResponse;
|
|
2282
|
+
class ListTagsForPrivateAccessApplicationRequest extends $tea.Model {
|
|
1907
2283
|
constructor(map) {
|
|
1908
2284
|
super(map);
|
|
1909
2285
|
}
|
|
1910
2286
|
static names() {
|
|
1911
2287
|
return {
|
|
1912
|
-
|
|
2288
|
+
applicationIds: 'ApplicationIds',
|
|
1913
2289
|
};
|
|
1914
2290
|
}
|
|
1915
2291
|
static types() {
|
|
1916
2292
|
return {
|
|
1917
|
-
|
|
2293
|
+
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
1918
2294
|
};
|
|
1919
2295
|
}
|
|
1920
2296
|
}
|
|
1921
|
-
exports.
|
|
1922
|
-
class
|
|
2297
|
+
exports.ListTagsForPrivateAccessApplicationRequest = ListTagsForPrivateAccessApplicationRequest;
|
|
2298
|
+
class ListTagsForPrivateAccessApplicationResponseBody extends $tea.Model {
|
|
1923
2299
|
constructor(map) {
|
|
1924
2300
|
super(map);
|
|
1925
2301
|
}
|
|
1926
2302
|
static names() {
|
|
1927
2303
|
return {
|
|
1928
|
-
|
|
2304
|
+
applications: 'Applications',
|
|
1929
2305
|
requestId: 'RequestId',
|
|
1930
2306
|
};
|
|
1931
2307
|
}
|
|
1932
2308
|
static types() {
|
|
1933
2309
|
return {
|
|
1934
|
-
|
|
2310
|
+
applications: { 'type': 'array', 'itemType': ListTagsForPrivateAccessApplicationResponseBodyApplications },
|
|
1935
2311
|
requestId: 'string',
|
|
1936
2312
|
};
|
|
1937
2313
|
}
|
|
1938
2314
|
}
|
|
1939
|
-
exports.
|
|
1940
|
-
class
|
|
2315
|
+
exports.ListTagsForPrivateAccessApplicationResponseBody = ListTagsForPrivateAccessApplicationResponseBody;
|
|
2316
|
+
class ListTagsForPrivateAccessApplicationResponse extends $tea.Model {
|
|
1941
2317
|
constructor(map) {
|
|
1942
2318
|
super(map);
|
|
1943
2319
|
}
|
|
@@ -1952,66 +2328,46 @@ class ListUserGroupsForPrivateAccessPolicyResponse extends $tea.Model {
|
|
|
1952
2328
|
return {
|
|
1953
2329
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1954
2330
|
statusCode: 'number',
|
|
1955
|
-
body:
|
|
2331
|
+
body: ListTagsForPrivateAccessApplicationResponseBody,
|
|
1956
2332
|
};
|
|
1957
2333
|
}
|
|
1958
2334
|
}
|
|
1959
|
-
exports.
|
|
1960
|
-
class
|
|
2335
|
+
exports.ListTagsForPrivateAccessApplicationResponse = ListTagsForPrivateAccessApplicationResponse;
|
|
2336
|
+
class ListTagsForPrivateAccessPolicyRequest extends $tea.Model {
|
|
1961
2337
|
constructor(map) {
|
|
1962
2338
|
super(map);
|
|
1963
2339
|
}
|
|
1964
2340
|
static names() {
|
|
1965
2341
|
return {
|
|
1966
|
-
|
|
1967
|
-
applicationType: 'ApplicationType',
|
|
1968
|
-
description: 'Description',
|
|
1969
|
-
dynamicRouteId: 'DynamicRouteId',
|
|
1970
|
-
dynamicRouteType: 'DynamicRouteType',
|
|
1971
|
-
modifyType: 'ModifyType',
|
|
1972
|
-
name: 'Name',
|
|
1973
|
-
nextHop: 'NextHop',
|
|
1974
|
-
priority: 'Priority',
|
|
1975
|
-
regionIds: 'RegionIds',
|
|
1976
|
-
status: 'Status',
|
|
1977
|
-
tagIds: 'TagIds',
|
|
2342
|
+
policyIds: 'PolicyIds',
|
|
1978
2343
|
};
|
|
1979
2344
|
}
|
|
1980
2345
|
static types() {
|
|
1981
2346
|
return {
|
|
1982
|
-
|
|
1983
|
-
applicationType: 'string',
|
|
1984
|
-
description: 'string',
|
|
1985
|
-
dynamicRouteId: 'string',
|
|
1986
|
-
dynamicRouteType: 'string',
|
|
1987
|
-
modifyType: 'string',
|
|
1988
|
-
name: 'string',
|
|
1989
|
-
nextHop: 'string',
|
|
1990
|
-
priority: 'number',
|
|
1991
|
-
regionIds: { 'type': 'array', 'itemType': 'string' },
|
|
1992
|
-
status: 'string',
|
|
1993
|
-
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
2347
|
+
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
1994
2348
|
};
|
|
1995
2349
|
}
|
|
1996
2350
|
}
|
|
1997
|
-
exports.
|
|
1998
|
-
class
|
|
2351
|
+
exports.ListTagsForPrivateAccessPolicyRequest = ListTagsForPrivateAccessPolicyRequest;
|
|
2352
|
+
class ListTagsForPrivateAccessPolicyResponseBody extends $tea.Model {
|
|
1999
2353
|
constructor(map) {
|
|
2000
2354
|
super(map);
|
|
2001
2355
|
}
|
|
2002
2356
|
static names() {
|
|
2003
2357
|
return {
|
|
2358
|
+
polices: 'Polices',
|
|
2004
2359
|
requestId: 'RequestId',
|
|
2005
2360
|
};
|
|
2006
2361
|
}
|
|
2007
2362
|
static types() {
|
|
2008
2363
|
return {
|
|
2364
|
+
polices: { 'type': 'array', 'itemType': ListTagsForPrivateAccessPolicyResponseBodyPolices },
|
|
2009
2365
|
requestId: 'string',
|
|
2010
2366
|
};
|
|
2011
2367
|
}
|
|
2012
2368
|
}
|
|
2013
|
-
exports.
|
|
2014
|
-
class
|
|
2369
|
+
exports.ListTagsForPrivateAccessPolicyResponseBody = ListTagsForPrivateAccessPolicyResponseBody;
|
|
2370
|
+
class ListTagsForPrivateAccessPolicyResponse extends $tea.Model {
|
|
2015
2371
|
constructor(map) {
|
|
2016
2372
|
super(map);
|
|
2017
2373
|
}
|
|
@@ -2026,58 +2382,80 @@ class UpdateDynamicRouteResponse extends $tea.Model {
|
|
|
2026
2382
|
return {
|
|
2027
2383
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2028
2384
|
statusCode: 'number',
|
|
2029
|
-
body:
|
|
2385
|
+
body: ListTagsForPrivateAccessPolicyResponseBody,
|
|
2030
2386
|
};
|
|
2031
2387
|
}
|
|
2032
2388
|
}
|
|
2033
|
-
exports.
|
|
2034
|
-
class
|
|
2389
|
+
exports.ListTagsForPrivateAccessPolicyResponse = ListTagsForPrivateAccessPolicyResponse;
|
|
2390
|
+
class ListUserDevicesRequest extends $tea.Model {
|
|
2035
2391
|
constructor(map) {
|
|
2036
2392
|
super(map);
|
|
2037
2393
|
}
|
|
2038
2394
|
static names() {
|
|
2039
2395
|
return {
|
|
2040
|
-
|
|
2041
|
-
|
|
2042
|
-
|
|
2043
|
-
|
|
2044
|
-
|
|
2045
|
-
|
|
2046
|
-
|
|
2047
|
-
|
|
2396
|
+
appStatuses: 'AppStatuses',
|
|
2397
|
+
currentPage: 'CurrentPage',
|
|
2398
|
+
department: 'Department',
|
|
2399
|
+
deviceBelong: 'DeviceBelong',
|
|
2400
|
+
deviceStatuses: 'DeviceStatuses',
|
|
2401
|
+
deviceTags: 'DeviceTags',
|
|
2402
|
+
deviceTypes: 'DeviceTypes',
|
|
2403
|
+
dlpStatuses: 'DlpStatuses',
|
|
2404
|
+
hostname: 'Hostname',
|
|
2405
|
+
iaStatuses: 'IaStatuses',
|
|
2406
|
+
mac: 'Mac',
|
|
2407
|
+
nacStatuses: 'NacStatuses',
|
|
2408
|
+
paStatuses: 'PaStatuses',
|
|
2409
|
+
pageSize: 'PageSize',
|
|
2410
|
+
saseUserId: 'SaseUserId',
|
|
2411
|
+
sharingStatus: 'SharingStatus',
|
|
2412
|
+
username: 'Username',
|
|
2048
2413
|
};
|
|
2049
2414
|
}
|
|
2050
2415
|
static types() {
|
|
2051
2416
|
return {
|
|
2052
|
-
|
|
2053
|
-
|
|
2054
|
-
|
|
2055
|
-
|
|
2056
|
-
|
|
2057
|
-
|
|
2058
|
-
|
|
2059
|
-
|
|
2417
|
+
appStatuses: { 'type': 'array', 'itemType': 'string' },
|
|
2418
|
+
currentPage: 'number',
|
|
2419
|
+
department: 'string',
|
|
2420
|
+
deviceBelong: 'string',
|
|
2421
|
+
deviceStatuses: { 'type': 'array', 'itemType': 'string' },
|
|
2422
|
+
deviceTags: { 'type': 'array', 'itemType': 'string' },
|
|
2423
|
+
deviceTypes: { 'type': 'array', 'itemType': 'string' },
|
|
2424
|
+
dlpStatuses: { 'type': 'array', 'itemType': 'string' },
|
|
2425
|
+
hostname: 'string',
|
|
2426
|
+
iaStatuses: { 'type': 'array', 'itemType': 'string' },
|
|
2427
|
+
mac: 'string',
|
|
2428
|
+
nacStatuses: { 'type': 'array', 'itemType': 'string' },
|
|
2429
|
+
paStatuses: { 'type': 'array', 'itemType': 'string' },
|
|
2430
|
+
pageSize: 'number',
|
|
2431
|
+
saseUserId: 'string',
|
|
2432
|
+
sharingStatus: 'boolean',
|
|
2433
|
+
username: 'string',
|
|
2060
2434
|
};
|
|
2061
2435
|
}
|
|
2062
2436
|
}
|
|
2063
|
-
exports.
|
|
2064
|
-
class
|
|
2437
|
+
exports.ListUserDevicesRequest = ListUserDevicesRequest;
|
|
2438
|
+
class ListUserDevicesResponseBody extends $tea.Model {
|
|
2065
2439
|
constructor(map) {
|
|
2066
2440
|
super(map);
|
|
2067
2441
|
}
|
|
2068
2442
|
static names() {
|
|
2069
2443
|
return {
|
|
2444
|
+
devices: 'Devices',
|
|
2070
2445
|
requestId: 'RequestId',
|
|
2446
|
+
totalNum: 'TotalNum',
|
|
2071
2447
|
};
|
|
2072
2448
|
}
|
|
2073
2449
|
static types() {
|
|
2074
2450
|
return {
|
|
2451
|
+
devices: { 'type': 'array', 'itemType': ListUserDevicesResponseBodyDevices },
|
|
2075
2452
|
requestId: 'string',
|
|
2453
|
+
totalNum: 'number',
|
|
2076
2454
|
};
|
|
2077
2455
|
}
|
|
2078
2456
|
}
|
|
2079
|
-
exports.
|
|
2080
|
-
class
|
|
2457
|
+
exports.ListUserDevicesResponseBody = ListUserDevicesResponseBody;
|
|
2458
|
+
class ListUserDevicesResponse extends $tea.Model {
|
|
2081
2459
|
constructor(map) {
|
|
2082
2460
|
super(map);
|
|
2083
2461
|
}
|
|
@@ -2092,66 +2470,58 @@ class UpdatePrivateAccessApplicationResponse extends $tea.Model {
|
|
|
2092
2470
|
return {
|
|
2093
2471
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2094
2472
|
statusCode: 'number',
|
|
2095
|
-
body:
|
|
2473
|
+
body: ListUserDevicesResponseBody,
|
|
2096
2474
|
};
|
|
2097
2475
|
}
|
|
2098
2476
|
}
|
|
2099
|
-
exports.
|
|
2100
|
-
class
|
|
2477
|
+
exports.ListUserDevicesResponse = ListUserDevicesResponse;
|
|
2478
|
+
class ListUserGroupsRequest extends $tea.Model {
|
|
2101
2479
|
constructor(map) {
|
|
2102
2480
|
super(map);
|
|
2103
2481
|
}
|
|
2104
2482
|
static names() {
|
|
2105
2483
|
return {
|
|
2106
|
-
|
|
2107
|
-
|
|
2108
|
-
|
|
2109
|
-
|
|
2110
|
-
|
|
2111
|
-
policyAction: 'PolicyAction',
|
|
2112
|
-
policyId: 'PolicyId',
|
|
2113
|
-
priority: 'Priority',
|
|
2114
|
-
status: 'Status',
|
|
2115
|
-
tagIds: 'TagIds',
|
|
2484
|
+
attributeValue: 'AttributeValue',
|
|
2485
|
+
currentPage: 'CurrentPage',
|
|
2486
|
+
name: 'Name',
|
|
2487
|
+
PAPolicyId: 'PAPolicyId',
|
|
2488
|
+
pageSize: 'PageSize',
|
|
2116
2489
|
userGroupIds: 'UserGroupIds',
|
|
2117
|
-
userGroupMode: 'UserGroupMode',
|
|
2118
2490
|
};
|
|
2119
2491
|
}
|
|
2120
2492
|
static types() {
|
|
2121
2493
|
return {
|
|
2122
|
-
|
|
2123
|
-
|
|
2124
|
-
|
|
2125
|
-
|
|
2126
|
-
|
|
2127
|
-
policyAction: 'string',
|
|
2128
|
-
policyId: 'string',
|
|
2129
|
-
priority: 'number',
|
|
2130
|
-
status: 'string',
|
|
2131
|
-
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
2494
|
+
attributeValue: 'string',
|
|
2495
|
+
currentPage: 'number',
|
|
2496
|
+
name: 'string',
|
|
2497
|
+
PAPolicyId: 'string',
|
|
2498
|
+
pageSize: 'number',
|
|
2132
2499
|
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
2133
|
-
userGroupMode: 'string',
|
|
2134
2500
|
};
|
|
2135
2501
|
}
|
|
2136
2502
|
}
|
|
2137
|
-
exports.
|
|
2138
|
-
class
|
|
2503
|
+
exports.ListUserGroupsRequest = ListUserGroupsRequest;
|
|
2504
|
+
class ListUserGroupsResponseBody extends $tea.Model {
|
|
2139
2505
|
constructor(map) {
|
|
2140
2506
|
super(map);
|
|
2141
2507
|
}
|
|
2142
2508
|
static names() {
|
|
2143
2509
|
return {
|
|
2144
2510
|
requestId: 'RequestId',
|
|
2511
|
+
totalNum: 'TotalNum',
|
|
2512
|
+
userGroups: 'UserGroups',
|
|
2145
2513
|
};
|
|
2146
2514
|
}
|
|
2147
2515
|
static types() {
|
|
2148
2516
|
return {
|
|
2149
2517
|
requestId: 'string',
|
|
2518
|
+
totalNum: 'number',
|
|
2519
|
+
userGroups: { 'type': 'array', 'itemType': ListUserGroupsResponseBodyUserGroups },
|
|
2150
2520
|
};
|
|
2151
2521
|
}
|
|
2152
2522
|
}
|
|
2153
|
-
exports.
|
|
2154
|
-
class
|
|
2523
|
+
exports.ListUserGroupsResponseBody = ListUserGroupsResponseBody;
|
|
2524
|
+
class ListUserGroupsResponse extends $tea.Model {
|
|
2155
2525
|
constructor(map) {
|
|
2156
2526
|
super(map);
|
|
2157
2527
|
}
|
|
@@ -2166,50 +2536,46 @@ class UpdatePrivateAccessPolicyResponse extends $tea.Model {
|
|
|
2166
2536
|
return {
|
|
2167
2537
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2168
2538
|
statusCode: 'number',
|
|
2169
|
-
body:
|
|
2539
|
+
body: ListUserGroupsResponseBody,
|
|
2170
2540
|
};
|
|
2171
2541
|
}
|
|
2172
2542
|
}
|
|
2173
|
-
exports.
|
|
2174
|
-
class
|
|
2543
|
+
exports.ListUserGroupsResponse = ListUserGroupsResponse;
|
|
2544
|
+
class ListUserGroupsForPrivateAccessPolicyRequest extends $tea.Model {
|
|
2175
2545
|
constructor(map) {
|
|
2176
2546
|
super(map);
|
|
2177
2547
|
}
|
|
2178
2548
|
static names() {
|
|
2179
2549
|
return {
|
|
2180
|
-
|
|
2181
|
-
description: 'Description',
|
|
2182
|
-
modifyType: 'ModifyType',
|
|
2183
|
-
userGroupId: 'UserGroupId',
|
|
2550
|
+
policyIds: 'PolicyIds',
|
|
2184
2551
|
};
|
|
2185
2552
|
}
|
|
2186
2553
|
static types() {
|
|
2187
2554
|
return {
|
|
2188
|
-
|
|
2189
|
-
description: 'string',
|
|
2190
|
-
modifyType: 'string',
|
|
2191
|
-
userGroupId: 'string',
|
|
2555
|
+
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
2192
2556
|
};
|
|
2193
2557
|
}
|
|
2194
2558
|
}
|
|
2195
|
-
exports.
|
|
2196
|
-
class
|
|
2559
|
+
exports.ListUserGroupsForPrivateAccessPolicyRequest = ListUserGroupsForPrivateAccessPolicyRequest;
|
|
2560
|
+
class ListUserGroupsForPrivateAccessPolicyResponseBody extends $tea.Model {
|
|
2197
2561
|
constructor(map) {
|
|
2198
2562
|
super(map);
|
|
2199
2563
|
}
|
|
2200
2564
|
static names() {
|
|
2201
2565
|
return {
|
|
2566
|
+
polices: 'Polices',
|
|
2202
2567
|
requestId: 'RequestId',
|
|
2203
2568
|
};
|
|
2204
2569
|
}
|
|
2205
2570
|
static types() {
|
|
2206
2571
|
return {
|
|
2572
|
+
polices: { 'type': 'array', 'itemType': ListUserGroupsForPrivateAccessPolicyResponseBodyPolices },
|
|
2207
2573
|
requestId: 'string',
|
|
2208
2574
|
};
|
|
2209
2575
|
}
|
|
2210
2576
|
}
|
|
2211
|
-
exports.
|
|
2212
|
-
class
|
|
2577
|
+
exports.ListUserGroupsForPrivateAccessPolicyResponseBody = ListUserGroupsForPrivateAccessPolicyResponseBody;
|
|
2578
|
+
class ListUserGroupsForPrivateAccessPolicyResponse extends $tea.Model {
|
|
2213
2579
|
constructor(map) {
|
|
2214
2580
|
super(map);
|
|
2215
2581
|
}
|
|
@@ -2224,74 +2590,66 @@ class UpdateUserGroupResponse extends $tea.Model {
|
|
|
2224
2590
|
return {
|
|
2225
2591
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2226
2592
|
statusCode: 'number',
|
|
2227
|
-
body:
|
|
2593
|
+
body: ListUserGroupsForPrivateAccessPolicyResponseBody,
|
|
2228
2594
|
};
|
|
2229
2595
|
}
|
|
2230
2596
|
}
|
|
2231
|
-
exports.
|
|
2232
|
-
class
|
|
2597
|
+
exports.ListUserGroupsForPrivateAccessPolicyResponse = ListUserGroupsForPrivateAccessPolicyResponse;
|
|
2598
|
+
class ListUserGroupsForRegistrationPolicyRequest extends $tea.Model {
|
|
2233
2599
|
constructor(map) {
|
|
2234
2600
|
super(map);
|
|
2235
2601
|
}
|
|
2236
2602
|
static names() {
|
|
2237
2603
|
return {
|
|
2238
|
-
|
|
2239
|
-
end: 'End',
|
|
2604
|
+
policyIds: 'PolicyIds',
|
|
2240
2605
|
};
|
|
2241
2606
|
}
|
|
2242
2607
|
static types() {
|
|
2243
2608
|
return {
|
|
2244
|
-
|
|
2245
|
-
end: 'number',
|
|
2609
|
+
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
2246
2610
|
};
|
|
2247
2611
|
}
|
|
2248
2612
|
}
|
|
2249
|
-
exports.
|
|
2250
|
-
class
|
|
2613
|
+
exports.ListUserGroupsForRegistrationPolicyRequest = ListUserGroupsForRegistrationPolicyRequest;
|
|
2614
|
+
class ListUserGroupsForRegistrationPolicyResponseBody extends $tea.Model {
|
|
2251
2615
|
constructor(map) {
|
|
2252
2616
|
super(map);
|
|
2253
2617
|
}
|
|
2254
2618
|
static names() {
|
|
2255
2619
|
return {
|
|
2256
|
-
|
|
2257
|
-
|
|
2258
|
-
userGroupType: 'UserGroupType',
|
|
2259
|
-
value: 'Value',
|
|
2620
|
+
policies: 'Policies',
|
|
2621
|
+
requestId: 'RequestId',
|
|
2260
2622
|
};
|
|
2261
2623
|
}
|
|
2262
2624
|
static types() {
|
|
2263
2625
|
return {
|
|
2264
|
-
|
|
2265
|
-
|
|
2266
|
-
userGroupType: 'string',
|
|
2267
|
-
value: 'string',
|
|
2626
|
+
policies: { 'type': 'array', 'itemType': ListUserGroupsForRegistrationPolicyResponseBodyPolicies },
|
|
2627
|
+
requestId: 'string',
|
|
2268
2628
|
};
|
|
2269
2629
|
}
|
|
2270
2630
|
}
|
|
2271
|
-
exports.
|
|
2272
|
-
class
|
|
2631
|
+
exports.ListUserGroupsForRegistrationPolicyResponseBody = ListUserGroupsForRegistrationPolicyResponseBody;
|
|
2632
|
+
class ListUserGroupsForRegistrationPolicyResponse extends $tea.Model {
|
|
2273
2633
|
constructor(map) {
|
|
2274
2634
|
super(map);
|
|
2275
2635
|
}
|
|
2276
2636
|
static names() {
|
|
2277
2637
|
return {
|
|
2278
|
-
|
|
2279
|
-
|
|
2280
|
-
|
|
2281
|
-
value: 'Value',
|
|
2638
|
+
headers: 'headers',
|
|
2639
|
+
statusCode: 'statusCode',
|
|
2640
|
+
body: 'body',
|
|
2282
2641
|
};
|
|
2283
2642
|
}
|
|
2284
2643
|
static types() {
|
|
2285
2644
|
return {
|
|
2286
|
-
|
|
2287
|
-
|
|
2288
|
-
|
|
2289
|
-
value: 'string',
|
|
2645
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2646
|
+
statusCode: 'number',
|
|
2647
|
+
body: ListUserGroupsForRegistrationPolicyResponseBody,
|
|
2290
2648
|
};
|
|
2291
2649
|
}
|
|
2292
2650
|
}
|
|
2293
|
-
exports.
|
|
2294
|
-
class
|
|
2651
|
+
exports.ListUserGroupsForRegistrationPolicyResponse = ListUserGroupsForRegistrationPolicyResponse;
|
|
2652
|
+
class UpdateDynamicRouteRequest extends $tea.Model {
|
|
2295
2653
|
constructor(map) {
|
|
2296
2654
|
super(map);
|
|
2297
2655
|
}
|
|
@@ -2299,10 +2657,10 @@ class GetDynamicRouteResponseBodyDynamicRoute extends $tea.Model {
|
|
|
2299
2657
|
return {
|
|
2300
2658
|
applicationIds: 'ApplicationIds',
|
|
2301
2659
|
applicationType: 'ApplicationType',
|
|
2302
|
-
createTime: 'CreateTime',
|
|
2303
2660
|
description: 'Description',
|
|
2304
2661
|
dynamicRouteId: 'DynamicRouteId',
|
|
2305
2662
|
dynamicRouteType: 'DynamicRouteType',
|
|
2663
|
+
modifyType: 'ModifyType',
|
|
2306
2664
|
name: 'Name',
|
|
2307
2665
|
nextHop: 'NextHop',
|
|
2308
2666
|
priority: 'Priority',
|
|
@@ -2315,10 +2673,10 @@ class GetDynamicRouteResponseBodyDynamicRoute extends $tea.Model {
|
|
|
2315
2673
|
return {
|
|
2316
2674
|
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
2317
2675
|
applicationType: 'string',
|
|
2318
|
-
createTime: 'string',
|
|
2319
2676
|
description: 'string',
|
|
2320
2677
|
dynamicRouteId: 'string',
|
|
2321
2678
|
dynamicRouteType: 'string',
|
|
2679
|
+
modifyType: 'string',
|
|
2322
2680
|
name: 'string',
|
|
2323
2681
|
nextHop: 'string',
|
|
2324
2682
|
priority: 'number',
|
|
@@ -2328,26 +2686,100 @@ class GetDynamicRouteResponseBodyDynamicRoute extends $tea.Model {
|
|
|
2328
2686
|
};
|
|
2329
2687
|
}
|
|
2330
2688
|
}
|
|
2331
|
-
exports.
|
|
2332
|
-
class
|
|
2689
|
+
exports.UpdateDynamicRouteRequest = UpdateDynamicRouteRequest;
|
|
2690
|
+
class UpdateDynamicRouteResponseBody extends $tea.Model {
|
|
2333
2691
|
constructor(map) {
|
|
2334
2692
|
super(map);
|
|
2335
2693
|
}
|
|
2336
2694
|
static names() {
|
|
2337
2695
|
return {
|
|
2338
|
-
|
|
2339
|
-
end: 'End',
|
|
2696
|
+
requestId: 'RequestId',
|
|
2340
2697
|
};
|
|
2341
2698
|
}
|
|
2342
2699
|
static types() {
|
|
2343
2700
|
return {
|
|
2344
|
-
|
|
2345
|
-
end: 'number',
|
|
2701
|
+
requestId: 'string',
|
|
2346
2702
|
};
|
|
2347
2703
|
}
|
|
2348
2704
|
}
|
|
2349
|
-
exports.
|
|
2350
|
-
class
|
|
2705
|
+
exports.UpdateDynamicRouteResponseBody = UpdateDynamicRouteResponseBody;
|
|
2706
|
+
class UpdateDynamicRouteResponse extends $tea.Model {
|
|
2707
|
+
constructor(map) {
|
|
2708
|
+
super(map);
|
|
2709
|
+
}
|
|
2710
|
+
static names() {
|
|
2711
|
+
return {
|
|
2712
|
+
headers: 'headers',
|
|
2713
|
+
statusCode: 'statusCode',
|
|
2714
|
+
body: 'body',
|
|
2715
|
+
};
|
|
2716
|
+
}
|
|
2717
|
+
static types() {
|
|
2718
|
+
return {
|
|
2719
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2720
|
+
statusCode: 'number',
|
|
2721
|
+
body: UpdateDynamicRouteResponseBody,
|
|
2722
|
+
};
|
|
2723
|
+
}
|
|
2724
|
+
}
|
|
2725
|
+
exports.UpdateDynamicRouteResponse = UpdateDynamicRouteResponse;
|
|
2726
|
+
class UpdateExcessiveDeviceRegistrationApplicationsStatusRequest extends $tea.Model {
|
|
2727
|
+
constructor(map) {
|
|
2728
|
+
super(map);
|
|
2729
|
+
}
|
|
2730
|
+
static names() {
|
|
2731
|
+
return {
|
|
2732
|
+
applicationIds: 'ApplicationIds',
|
|
2733
|
+
status: 'Status',
|
|
2734
|
+
};
|
|
2735
|
+
}
|
|
2736
|
+
static types() {
|
|
2737
|
+
return {
|
|
2738
|
+
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
2739
|
+
status: 'string',
|
|
2740
|
+
};
|
|
2741
|
+
}
|
|
2742
|
+
}
|
|
2743
|
+
exports.UpdateExcessiveDeviceRegistrationApplicationsStatusRequest = UpdateExcessiveDeviceRegistrationApplicationsStatusRequest;
|
|
2744
|
+
class UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBody extends $tea.Model {
|
|
2745
|
+
constructor(map) {
|
|
2746
|
+
super(map);
|
|
2747
|
+
}
|
|
2748
|
+
static names() {
|
|
2749
|
+
return {
|
|
2750
|
+
applications: 'Applications',
|
|
2751
|
+
requestId: 'RequestId',
|
|
2752
|
+
};
|
|
2753
|
+
}
|
|
2754
|
+
static types() {
|
|
2755
|
+
return {
|
|
2756
|
+
applications: { 'type': 'array', 'itemType': UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBodyApplications },
|
|
2757
|
+
requestId: 'string',
|
|
2758
|
+
};
|
|
2759
|
+
}
|
|
2760
|
+
}
|
|
2761
|
+
exports.UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBody = UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBody;
|
|
2762
|
+
class UpdateExcessiveDeviceRegistrationApplicationsStatusResponse extends $tea.Model {
|
|
2763
|
+
constructor(map) {
|
|
2764
|
+
super(map);
|
|
2765
|
+
}
|
|
2766
|
+
static names() {
|
|
2767
|
+
return {
|
|
2768
|
+
headers: 'headers',
|
|
2769
|
+
statusCode: 'statusCode',
|
|
2770
|
+
body: 'body',
|
|
2771
|
+
};
|
|
2772
|
+
}
|
|
2773
|
+
static types() {
|
|
2774
|
+
return {
|
|
2775
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2776
|
+
statusCode: 'number',
|
|
2777
|
+
body: UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBody,
|
|
2778
|
+
};
|
|
2779
|
+
}
|
|
2780
|
+
}
|
|
2781
|
+
exports.UpdateExcessiveDeviceRegistrationApplicationsStatusResponse = UpdateExcessiveDeviceRegistrationApplicationsStatusResponse;
|
|
2782
|
+
class UpdatePrivateAccessApplicationRequest extends $tea.Model {
|
|
2351
2783
|
constructor(map) {
|
|
2352
2784
|
super(map);
|
|
2353
2785
|
}
|
|
@@ -2355,10 +2787,8 @@ class GetPrivateAccessApplicationResponseBodyApplication extends $tea.Model {
|
|
|
2355
2787
|
return {
|
|
2356
2788
|
addresses: 'Addresses',
|
|
2357
2789
|
applicationId: 'ApplicationId',
|
|
2358
|
-
createTime: 'CreateTime',
|
|
2359
2790
|
description: 'Description',
|
|
2360
|
-
|
|
2361
|
-
policyIds: 'PolicyIds',
|
|
2791
|
+
modifyType: 'ModifyType',
|
|
2362
2792
|
portRanges: 'PortRanges',
|
|
2363
2793
|
protocol: 'Protocol',
|
|
2364
2794
|
status: 'Status',
|
|
@@ -2367,21 +2797,1285 @@ class GetPrivateAccessApplicationResponseBodyApplication extends $tea.Model {
|
|
|
2367
2797
|
}
|
|
2368
2798
|
static types() {
|
|
2369
2799
|
return {
|
|
2370
|
-
addresses: { 'type': 'array', 'itemType': 'string' },
|
|
2800
|
+
addresses: { 'type': 'array', 'itemType': 'string' },
|
|
2801
|
+
applicationId: 'string',
|
|
2802
|
+
description: 'string',
|
|
2803
|
+
modifyType: 'string',
|
|
2804
|
+
portRanges: { 'type': 'array', 'itemType': UpdatePrivateAccessApplicationRequestPortRanges },
|
|
2805
|
+
protocol: 'string',
|
|
2806
|
+
status: 'string',
|
|
2807
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
2808
|
+
};
|
|
2809
|
+
}
|
|
2810
|
+
}
|
|
2811
|
+
exports.UpdatePrivateAccessApplicationRequest = UpdatePrivateAccessApplicationRequest;
|
|
2812
|
+
class UpdatePrivateAccessApplicationResponseBody extends $tea.Model {
|
|
2813
|
+
constructor(map) {
|
|
2814
|
+
super(map);
|
|
2815
|
+
}
|
|
2816
|
+
static names() {
|
|
2817
|
+
return {
|
|
2818
|
+
requestId: 'RequestId',
|
|
2819
|
+
};
|
|
2820
|
+
}
|
|
2821
|
+
static types() {
|
|
2822
|
+
return {
|
|
2823
|
+
requestId: 'string',
|
|
2824
|
+
};
|
|
2825
|
+
}
|
|
2826
|
+
}
|
|
2827
|
+
exports.UpdatePrivateAccessApplicationResponseBody = UpdatePrivateAccessApplicationResponseBody;
|
|
2828
|
+
class UpdatePrivateAccessApplicationResponse extends $tea.Model {
|
|
2829
|
+
constructor(map) {
|
|
2830
|
+
super(map);
|
|
2831
|
+
}
|
|
2832
|
+
static names() {
|
|
2833
|
+
return {
|
|
2834
|
+
headers: 'headers',
|
|
2835
|
+
statusCode: 'statusCode',
|
|
2836
|
+
body: 'body',
|
|
2837
|
+
};
|
|
2838
|
+
}
|
|
2839
|
+
static types() {
|
|
2840
|
+
return {
|
|
2841
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2842
|
+
statusCode: 'number',
|
|
2843
|
+
body: UpdatePrivateAccessApplicationResponseBody,
|
|
2844
|
+
};
|
|
2845
|
+
}
|
|
2846
|
+
}
|
|
2847
|
+
exports.UpdatePrivateAccessApplicationResponse = UpdatePrivateAccessApplicationResponse;
|
|
2848
|
+
class UpdatePrivateAccessPolicyRequest extends $tea.Model {
|
|
2849
|
+
constructor(map) {
|
|
2850
|
+
super(map);
|
|
2851
|
+
}
|
|
2852
|
+
static names() {
|
|
2853
|
+
return {
|
|
2854
|
+
applicationIds: 'ApplicationIds',
|
|
2855
|
+
applicationType: 'ApplicationType',
|
|
2856
|
+
customUserAttributes: 'CustomUserAttributes',
|
|
2857
|
+
description: 'Description',
|
|
2858
|
+
modifyType: 'ModifyType',
|
|
2859
|
+
policyAction: 'PolicyAction',
|
|
2860
|
+
policyId: 'PolicyId',
|
|
2861
|
+
priority: 'Priority',
|
|
2862
|
+
status: 'Status',
|
|
2863
|
+
tagIds: 'TagIds',
|
|
2864
|
+
userGroupIds: 'UserGroupIds',
|
|
2865
|
+
userGroupMode: 'UserGroupMode',
|
|
2866
|
+
};
|
|
2867
|
+
}
|
|
2868
|
+
static types() {
|
|
2869
|
+
return {
|
|
2870
|
+
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
2871
|
+
applicationType: 'string',
|
|
2872
|
+
customUserAttributes: { 'type': 'array', 'itemType': UpdatePrivateAccessPolicyRequestCustomUserAttributes },
|
|
2873
|
+
description: 'string',
|
|
2874
|
+
modifyType: 'string',
|
|
2875
|
+
policyAction: 'string',
|
|
2876
|
+
policyId: 'string',
|
|
2877
|
+
priority: 'number',
|
|
2878
|
+
status: 'string',
|
|
2879
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
2880
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
2881
|
+
userGroupMode: 'string',
|
|
2882
|
+
};
|
|
2883
|
+
}
|
|
2884
|
+
}
|
|
2885
|
+
exports.UpdatePrivateAccessPolicyRequest = UpdatePrivateAccessPolicyRequest;
|
|
2886
|
+
class UpdatePrivateAccessPolicyResponseBody extends $tea.Model {
|
|
2887
|
+
constructor(map) {
|
|
2888
|
+
super(map);
|
|
2889
|
+
}
|
|
2890
|
+
static names() {
|
|
2891
|
+
return {
|
|
2892
|
+
requestId: 'RequestId',
|
|
2893
|
+
};
|
|
2894
|
+
}
|
|
2895
|
+
static types() {
|
|
2896
|
+
return {
|
|
2897
|
+
requestId: 'string',
|
|
2898
|
+
};
|
|
2899
|
+
}
|
|
2900
|
+
}
|
|
2901
|
+
exports.UpdatePrivateAccessPolicyResponseBody = UpdatePrivateAccessPolicyResponseBody;
|
|
2902
|
+
class UpdatePrivateAccessPolicyResponse extends $tea.Model {
|
|
2903
|
+
constructor(map) {
|
|
2904
|
+
super(map);
|
|
2905
|
+
}
|
|
2906
|
+
static names() {
|
|
2907
|
+
return {
|
|
2908
|
+
headers: 'headers',
|
|
2909
|
+
statusCode: 'statusCode',
|
|
2910
|
+
body: 'body',
|
|
2911
|
+
};
|
|
2912
|
+
}
|
|
2913
|
+
static types() {
|
|
2914
|
+
return {
|
|
2915
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2916
|
+
statusCode: 'number',
|
|
2917
|
+
body: UpdatePrivateAccessPolicyResponseBody,
|
|
2918
|
+
};
|
|
2919
|
+
}
|
|
2920
|
+
}
|
|
2921
|
+
exports.UpdatePrivateAccessPolicyResponse = UpdatePrivateAccessPolicyResponse;
|
|
2922
|
+
class UpdateRegistrationPolicyRequest extends $tea.Model {
|
|
2923
|
+
constructor(map) {
|
|
2924
|
+
super(map);
|
|
2925
|
+
}
|
|
2926
|
+
static names() {
|
|
2927
|
+
return {
|
|
2928
|
+
companyLimitCount: 'CompanyLimitCount',
|
|
2929
|
+
companyLimitType: 'CompanyLimitType',
|
|
2930
|
+
description: 'Description',
|
|
2931
|
+
matchMode: 'MatchMode',
|
|
2932
|
+
name: 'Name',
|
|
2933
|
+
personalLimitCount: 'PersonalLimitCount',
|
|
2934
|
+
personalLimitType: 'PersonalLimitType',
|
|
2935
|
+
policyId: 'PolicyId',
|
|
2936
|
+
priority: 'Priority',
|
|
2937
|
+
status: 'Status',
|
|
2938
|
+
userGroupIds: 'UserGroupIds',
|
|
2939
|
+
whitelist: 'Whitelist',
|
|
2940
|
+
};
|
|
2941
|
+
}
|
|
2942
|
+
static types() {
|
|
2943
|
+
return {
|
|
2944
|
+
companyLimitCount: UpdateRegistrationPolicyRequestCompanyLimitCount,
|
|
2945
|
+
companyLimitType: 'string',
|
|
2946
|
+
description: 'string',
|
|
2947
|
+
matchMode: 'string',
|
|
2948
|
+
name: 'string',
|
|
2949
|
+
personalLimitCount: UpdateRegistrationPolicyRequestPersonalLimitCount,
|
|
2950
|
+
personalLimitType: 'string',
|
|
2951
|
+
policyId: 'string',
|
|
2952
|
+
priority: 'number',
|
|
2953
|
+
status: 'string',
|
|
2954
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
2955
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
2956
|
+
};
|
|
2957
|
+
}
|
|
2958
|
+
}
|
|
2959
|
+
exports.UpdateRegistrationPolicyRequest = UpdateRegistrationPolicyRequest;
|
|
2960
|
+
class UpdateRegistrationPolicyShrinkRequest extends $tea.Model {
|
|
2961
|
+
constructor(map) {
|
|
2962
|
+
super(map);
|
|
2963
|
+
}
|
|
2964
|
+
static names() {
|
|
2965
|
+
return {
|
|
2966
|
+
companyLimitCountShrink: 'CompanyLimitCount',
|
|
2967
|
+
companyLimitType: 'CompanyLimitType',
|
|
2968
|
+
description: 'Description',
|
|
2969
|
+
matchMode: 'MatchMode',
|
|
2970
|
+
name: 'Name',
|
|
2971
|
+
personalLimitCountShrink: 'PersonalLimitCount',
|
|
2972
|
+
personalLimitType: 'PersonalLimitType',
|
|
2973
|
+
policyId: 'PolicyId',
|
|
2974
|
+
priority: 'Priority',
|
|
2975
|
+
status: 'Status',
|
|
2976
|
+
userGroupIds: 'UserGroupIds',
|
|
2977
|
+
whitelist: 'Whitelist',
|
|
2978
|
+
};
|
|
2979
|
+
}
|
|
2980
|
+
static types() {
|
|
2981
|
+
return {
|
|
2982
|
+
companyLimitCountShrink: 'string',
|
|
2983
|
+
companyLimitType: 'string',
|
|
2984
|
+
description: 'string',
|
|
2985
|
+
matchMode: 'string',
|
|
2986
|
+
name: 'string',
|
|
2987
|
+
personalLimitCountShrink: 'string',
|
|
2988
|
+
personalLimitType: 'string',
|
|
2989
|
+
policyId: 'string',
|
|
2990
|
+
priority: 'number',
|
|
2991
|
+
status: 'string',
|
|
2992
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
2993
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
2994
|
+
};
|
|
2995
|
+
}
|
|
2996
|
+
}
|
|
2997
|
+
exports.UpdateRegistrationPolicyShrinkRequest = UpdateRegistrationPolicyShrinkRequest;
|
|
2998
|
+
class UpdateRegistrationPolicyResponseBody extends $tea.Model {
|
|
2999
|
+
constructor(map) {
|
|
3000
|
+
super(map);
|
|
3001
|
+
}
|
|
3002
|
+
static names() {
|
|
3003
|
+
return {
|
|
3004
|
+
policy: 'Policy',
|
|
3005
|
+
requestId: 'RequestId',
|
|
3006
|
+
};
|
|
3007
|
+
}
|
|
3008
|
+
static types() {
|
|
3009
|
+
return {
|
|
3010
|
+
policy: UpdateRegistrationPolicyResponseBodyPolicy,
|
|
3011
|
+
requestId: 'string',
|
|
3012
|
+
};
|
|
3013
|
+
}
|
|
3014
|
+
}
|
|
3015
|
+
exports.UpdateRegistrationPolicyResponseBody = UpdateRegistrationPolicyResponseBody;
|
|
3016
|
+
class UpdateRegistrationPolicyResponse extends $tea.Model {
|
|
3017
|
+
constructor(map) {
|
|
3018
|
+
super(map);
|
|
3019
|
+
}
|
|
3020
|
+
static names() {
|
|
3021
|
+
return {
|
|
3022
|
+
headers: 'headers',
|
|
3023
|
+
statusCode: 'statusCode',
|
|
3024
|
+
body: 'body',
|
|
3025
|
+
};
|
|
3026
|
+
}
|
|
3027
|
+
static types() {
|
|
3028
|
+
return {
|
|
3029
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3030
|
+
statusCode: 'number',
|
|
3031
|
+
body: UpdateRegistrationPolicyResponseBody,
|
|
3032
|
+
};
|
|
3033
|
+
}
|
|
3034
|
+
}
|
|
3035
|
+
exports.UpdateRegistrationPolicyResponse = UpdateRegistrationPolicyResponse;
|
|
3036
|
+
class UpdateUserDevicesSharingStatusRequest extends $tea.Model {
|
|
3037
|
+
constructor(map) {
|
|
3038
|
+
super(map);
|
|
3039
|
+
}
|
|
3040
|
+
static names() {
|
|
3041
|
+
return {
|
|
3042
|
+
deviceTags: 'DeviceTags',
|
|
3043
|
+
sharingStatus: 'SharingStatus',
|
|
3044
|
+
};
|
|
3045
|
+
}
|
|
3046
|
+
static types() {
|
|
3047
|
+
return {
|
|
3048
|
+
deviceTags: { 'type': 'array', 'itemType': 'string' },
|
|
3049
|
+
sharingStatus: 'boolean',
|
|
3050
|
+
};
|
|
3051
|
+
}
|
|
3052
|
+
}
|
|
3053
|
+
exports.UpdateUserDevicesSharingStatusRequest = UpdateUserDevicesSharingStatusRequest;
|
|
3054
|
+
class UpdateUserDevicesSharingStatusResponseBody extends $tea.Model {
|
|
3055
|
+
constructor(map) {
|
|
3056
|
+
super(map);
|
|
3057
|
+
}
|
|
3058
|
+
static names() {
|
|
3059
|
+
return {
|
|
3060
|
+
devices: 'Devices',
|
|
3061
|
+
requestId: 'RequestId',
|
|
3062
|
+
};
|
|
3063
|
+
}
|
|
3064
|
+
static types() {
|
|
3065
|
+
return {
|
|
3066
|
+
devices: { 'type': 'array', 'itemType': UpdateUserDevicesSharingStatusResponseBodyDevices },
|
|
3067
|
+
requestId: 'string',
|
|
3068
|
+
};
|
|
3069
|
+
}
|
|
3070
|
+
}
|
|
3071
|
+
exports.UpdateUserDevicesSharingStatusResponseBody = UpdateUserDevicesSharingStatusResponseBody;
|
|
3072
|
+
class UpdateUserDevicesSharingStatusResponse extends $tea.Model {
|
|
3073
|
+
constructor(map) {
|
|
3074
|
+
super(map);
|
|
3075
|
+
}
|
|
3076
|
+
static names() {
|
|
3077
|
+
return {
|
|
3078
|
+
headers: 'headers',
|
|
3079
|
+
statusCode: 'statusCode',
|
|
3080
|
+
body: 'body',
|
|
3081
|
+
};
|
|
3082
|
+
}
|
|
3083
|
+
static types() {
|
|
3084
|
+
return {
|
|
3085
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3086
|
+
statusCode: 'number',
|
|
3087
|
+
body: UpdateUserDevicesSharingStatusResponseBody,
|
|
3088
|
+
};
|
|
3089
|
+
}
|
|
3090
|
+
}
|
|
3091
|
+
exports.UpdateUserDevicesSharingStatusResponse = UpdateUserDevicesSharingStatusResponse;
|
|
3092
|
+
class UpdateUserDevicesStatusRequest extends $tea.Model {
|
|
3093
|
+
constructor(map) {
|
|
3094
|
+
super(map);
|
|
3095
|
+
}
|
|
3096
|
+
static names() {
|
|
3097
|
+
return {
|
|
3098
|
+
deviceAction: 'DeviceAction',
|
|
3099
|
+
deviceTags: 'DeviceTags',
|
|
3100
|
+
};
|
|
3101
|
+
}
|
|
3102
|
+
static types() {
|
|
3103
|
+
return {
|
|
3104
|
+
deviceAction: 'string',
|
|
3105
|
+
deviceTags: { 'type': 'array', 'itemType': 'string' },
|
|
3106
|
+
};
|
|
3107
|
+
}
|
|
3108
|
+
}
|
|
3109
|
+
exports.UpdateUserDevicesStatusRequest = UpdateUserDevicesStatusRequest;
|
|
3110
|
+
class UpdateUserDevicesStatusResponseBody extends $tea.Model {
|
|
3111
|
+
constructor(map) {
|
|
3112
|
+
super(map);
|
|
3113
|
+
}
|
|
3114
|
+
static names() {
|
|
3115
|
+
return {
|
|
3116
|
+
devices: 'Devices',
|
|
3117
|
+
requestId: 'RequestId',
|
|
3118
|
+
};
|
|
3119
|
+
}
|
|
3120
|
+
static types() {
|
|
3121
|
+
return {
|
|
3122
|
+
devices: { 'type': 'array', 'itemType': UpdateUserDevicesStatusResponseBodyDevices },
|
|
3123
|
+
requestId: 'string',
|
|
3124
|
+
};
|
|
3125
|
+
}
|
|
3126
|
+
}
|
|
3127
|
+
exports.UpdateUserDevicesStatusResponseBody = UpdateUserDevicesStatusResponseBody;
|
|
3128
|
+
class UpdateUserDevicesStatusResponse extends $tea.Model {
|
|
3129
|
+
constructor(map) {
|
|
3130
|
+
super(map);
|
|
3131
|
+
}
|
|
3132
|
+
static names() {
|
|
3133
|
+
return {
|
|
3134
|
+
headers: 'headers',
|
|
3135
|
+
statusCode: 'statusCode',
|
|
3136
|
+
body: 'body',
|
|
3137
|
+
};
|
|
3138
|
+
}
|
|
3139
|
+
static types() {
|
|
3140
|
+
return {
|
|
3141
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3142
|
+
statusCode: 'number',
|
|
3143
|
+
body: UpdateUserDevicesStatusResponseBody,
|
|
3144
|
+
};
|
|
3145
|
+
}
|
|
3146
|
+
}
|
|
3147
|
+
exports.UpdateUserDevicesStatusResponse = UpdateUserDevicesStatusResponse;
|
|
3148
|
+
class UpdateUserGroupRequest extends $tea.Model {
|
|
3149
|
+
constructor(map) {
|
|
3150
|
+
super(map);
|
|
3151
|
+
}
|
|
3152
|
+
static names() {
|
|
3153
|
+
return {
|
|
3154
|
+
attributes: 'Attributes',
|
|
3155
|
+
description: 'Description',
|
|
3156
|
+
modifyType: 'ModifyType',
|
|
3157
|
+
userGroupId: 'UserGroupId',
|
|
3158
|
+
};
|
|
3159
|
+
}
|
|
3160
|
+
static types() {
|
|
3161
|
+
return {
|
|
3162
|
+
attributes: { 'type': 'array', 'itemType': UpdateUserGroupRequestAttributes },
|
|
3163
|
+
description: 'string',
|
|
3164
|
+
modifyType: 'string',
|
|
3165
|
+
userGroupId: 'string',
|
|
3166
|
+
};
|
|
3167
|
+
}
|
|
3168
|
+
}
|
|
3169
|
+
exports.UpdateUserGroupRequest = UpdateUserGroupRequest;
|
|
3170
|
+
class UpdateUserGroupResponseBody extends $tea.Model {
|
|
3171
|
+
constructor(map) {
|
|
3172
|
+
super(map);
|
|
3173
|
+
}
|
|
3174
|
+
static names() {
|
|
3175
|
+
return {
|
|
3176
|
+
requestId: 'RequestId',
|
|
3177
|
+
};
|
|
3178
|
+
}
|
|
3179
|
+
static types() {
|
|
3180
|
+
return {
|
|
3181
|
+
requestId: 'string',
|
|
3182
|
+
};
|
|
3183
|
+
}
|
|
3184
|
+
}
|
|
3185
|
+
exports.UpdateUserGroupResponseBody = UpdateUserGroupResponseBody;
|
|
3186
|
+
class UpdateUserGroupResponse extends $tea.Model {
|
|
3187
|
+
constructor(map) {
|
|
3188
|
+
super(map);
|
|
3189
|
+
}
|
|
3190
|
+
static names() {
|
|
3191
|
+
return {
|
|
3192
|
+
headers: 'headers',
|
|
3193
|
+
statusCode: 'statusCode',
|
|
3194
|
+
body: 'body',
|
|
3195
|
+
};
|
|
3196
|
+
}
|
|
3197
|
+
static types() {
|
|
3198
|
+
return {
|
|
3199
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3200
|
+
statusCode: 'number',
|
|
3201
|
+
body: UpdateUserGroupResponseBody,
|
|
3202
|
+
};
|
|
3203
|
+
}
|
|
3204
|
+
}
|
|
3205
|
+
exports.UpdateUserGroupResponse = UpdateUserGroupResponse;
|
|
3206
|
+
class CreatePrivateAccessApplicationRequestPortRanges extends $tea.Model {
|
|
3207
|
+
constructor(map) {
|
|
3208
|
+
super(map);
|
|
3209
|
+
}
|
|
3210
|
+
static names() {
|
|
3211
|
+
return {
|
|
3212
|
+
begin: 'Begin',
|
|
3213
|
+
end: 'End',
|
|
3214
|
+
};
|
|
3215
|
+
}
|
|
3216
|
+
static types() {
|
|
3217
|
+
return {
|
|
3218
|
+
begin: 'number',
|
|
3219
|
+
end: 'number',
|
|
3220
|
+
};
|
|
3221
|
+
}
|
|
3222
|
+
}
|
|
3223
|
+
exports.CreatePrivateAccessApplicationRequestPortRanges = CreatePrivateAccessApplicationRequestPortRanges;
|
|
3224
|
+
class CreatePrivateAccessPolicyRequestCustomUserAttributes extends $tea.Model {
|
|
3225
|
+
constructor(map) {
|
|
3226
|
+
super(map);
|
|
3227
|
+
}
|
|
3228
|
+
static names() {
|
|
3229
|
+
return {
|
|
3230
|
+
idpId: 'IdpId',
|
|
3231
|
+
relation: 'Relation',
|
|
3232
|
+
userGroupType: 'UserGroupType',
|
|
3233
|
+
value: 'Value',
|
|
3234
|
+
};
|
|
3235
|
+
}
|
|
3236
|
+
static types() {
|
|
3237
|
+
return {
|
|
3238
|
+
idpId: 'number',
|
|
3239
|
+
relation: 'string',
|
|
3240
|
+
userGroupType: 'string',
|
|
3241
|
+
value: 'string',
|
|
3242
|
+
};
|
|
3243
|
+
}
|
|
3244
|
+
}
|
|
3245
|
+
exports.CreatePrivateAccessPolicyRequestCustomUserAttributes = CreatePrivateAccessPolicyRequestCustomUserAttributes;
|
|
3246
|
+
class CreateRegistrationPolicyRequestCompanyLimitCount extends $tea.Model {
|
|
3247
|
+
constructor(map) {
|
|
3248
|
+
super(map);
|
|
3249
|
+
}
|
|
3250
|
+
static names() {
|
|
3251
|
+
return {
|
|
3252
|
+
all: 'All',
|
|
3253
|
+
mobile: 'Mobile',
|
|
3254
|
+
PC: 'PC',
|
|
3255
|
+
};
|
|
3256
|
+
}
|
|
3257
|
+
static types() {
|
|
3258
|
+
return {
|
|
3259
|
+
all: 'number',
|
|
3260
|
+
mobile: 'number',
|
|
3261
|
+
PC: 'number',
|
|
3262
|
+
};
|
|
3263
|
+
}
|
|
3264
|
+
}
|
|
3265
|
+
exports.CreateRegistrationPolicyRequestCompanyLimitCount = CreateRegistrationPolicyRequestCompanyLimitCount;
|
|
3266
|
+
class CreateRegistrationPolicyRequestPersonalLimitCount extends $tea.Model {
|
|
3267
|
+
constructor(map) {
|
|
3268
|
+
super(map);
|
|
3269
|
+
}
|
|
3270
|
+
static names() {
|
|
3271
|
+
return {
|
|
3272
|
+
all: 'All',
|
|
3273
|
+
mobile: 'Mobile',
|
|
3274
|
+
PC: 'PC',
|
|
3275
|
+
};
|
|
3276
|
+
}
|
|
3277
|
+
static types() {
|
|
3278
|
+
return {
|
|
3279
|
+
all: 'number',
|
|
3280
|
+
mobile: 'number',
|
|
3281
|
+
PC: 'number',
|
|
3282
|
+
};
|
|
3283
|
+
}
|
|
3284
|
+
}
|
|
3285
|
+
exports.CreateRegistrationPolicyRequestPersonalLimitCount = CreateRegistrationPolicyRequestPersonalLimitCount;
|
|
3286
|
+
class CreateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount extends $tea.Model {
|
|
3287
|
+
constructor(map) {
|
|
3288
|
+
super(map);
|
|
3289
|
+
}
|
|
3290
|
+
static names() {
|
|
3291
|
+
return {
|
|
3292
|
+
all: 'All',
|
|
3293
|
+
mobile: 'Mobile',
|
|
3294
|
+
PC: 'PC',
|
|
3295
|
+
};
|
|
3296
|
+
}
|
|
3297
|
+
static types() {
|
|
3298
|
+
return {
|
|
3299
|
+
all: 'number',
|
|
3300
|
+
mobile: 'number',
|
|
3301
|
+
PC: 'number',
|
|
3302
|
+
};
|
|
3303
|
+
}
|
|
3304
|
+
}
|
|
3305
|
+
exports.CreateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount = CreateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount;
|
|
3306
|
+
class CreateRegistrationPolicyResponseBodyPolicyLimitDetail extends $tea.Model {
|
|
3307
|
+
constructor(map) {
|
|
3308
|
+
super(map);
|
|
3309
|
+
}
|
|
3310
|
+
static names() {
|
|
3311
|
+
return {
|
|
3312
|
+
deviceBelong: 'DeviceBelong',
|
|
3313
|
+
limitCount: 'LimitCount',
|
|
3314
|
+
limitType: 'LimitType',
|
|
3315
|
+
};
|
|
3316
|
+
}
|
|
3317
|
+
static types() {
|
|
3318
|
+
return {
|
|
3319
|
+
deviceBelong: 'string',
|
|
3320
|
+
limitCount: CreateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount,
|
|
3321
|
+
limitType: 'string',
|
|
3322
|
+
};
|
|
3323
|
+
}
|
|
3324
|
+
}
|
|
3325
|
+
exports.CreateRegistrationPolicyResponseBodyPolicyLimitDetail = CreateRegistrationPolicyResponseBodyPolicyLimitDetail;
|
|
3326
|
+
class CreateRegistrationPolicyResponseBodyPolicy extends $tea.Model {
|
|
3327
|
+
constructor(map) {
|
|
3328
|
+
super(map);
|
|
3329
|
+
}
|
|
3330
|
+
static names() {
|
|
3331
|
+
return {
|
|
3332
|
+
createTime: 'CreateTime',
|
|
3333
|
+
description: 'Description',
|
|
3334
|
+
limitDetail: 'LimitDetail',
|
|
3335
|
+
matchMode: 'MatchMode',
|
|
3336
|
+
name: 'Name',
|
|
3337
|
+
policyId: 'PolicyId',
|
|
3338
|
+
priority: 'Priority',
|
|
3339
|
+
status: 'Status',
|
|
3340
|
+
userGroupIds: 'UserGroupIds',
|
|
3341
|
+
whitelist: 'Whitelist',
|
|
3342
|
+
};
|
|
3343
|
+
}
|
|
3344
|
+
static types() {
|
|
3345
|
+
return {
|
|
3346
|
+
createTime: 'string',
|
|
3347
|
+
description: 'string',
|
|
3348
|
+
limitDetail: { 'type': 'array', 'itemType': CreateRegistrationPolicyResponseBodyPolicyLimitDetail },
|
|
3349
|
+
matchMode: 'string',
|
|
3350
|
+
name: 'string',
|
|
3351
|
+
policyId: 'string',
|
|
3352
|
+
priority: 'string',
|
|
3353
|
+
status: 'string',
|
|
3354
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
3355
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
3356
|
+
};
|
|
3357
|
+
}
|
|
3358
|
+
}
|
|
3359
|
+
exports.CreateRegistrationPolicyResponseBodyPolicy = CreateRegistrationPolicyResponseBodyPolicy;
|
|
3360
|
+
class CreateUserGroupRequestAttributes extends $tea.Model {
|
|
3361
|
+
constructor(map) {
|
|
3362
|
+
super(map);
|
|
3363
|
+
}
|
|
3364
|
+
static names() {
|
|
3365
|
+
return {
|
|
3366
|
+
idpId: 'IdpId',
|
|
3367
|
+
relation: 'Relation',
|
|
3368
|
+
userGroupType: 'UserGroupType',
|
|
3369
|
+
value: 'Value',
|
|
3370
|
+
};
|
|
3371
|
+
}
|
|
3372
|
+
static types() {
|
|
3373
|
+
return {
|
|
3374
|
+
idpId: 'number',
|
|
3375
|
+
relation: 'string',
|
|
3376
|
+
userGroupType: 'string',
|
|
3377
|
+
value: 'string',
|
|
3378
|
+
};
|
|
3379
|
+
}
|
|
3380
|
+
}
|
|
3381
|
+
exports.CreateUserGroupRequestAttributes = CreateUserGroupRequestAttributes;
|
|
3382
|
+
class GetDynamicRouteResponseBodyDynamicRoute extends $tea.Model {
|
|
3383
|
+
constructor(map) {
|
|
3384
|
+
super(map);
|
|
3385
|
+
}
|
|
3386
|
+
static names() {
|
|
3387
|
+
return {
|
|
3388
|
+
applicationIds: 'ApplicationIds',
|
|
3389
|
+
applicationType: 'ApplicationType',
|
|
3390
|
+
createTime: 'CreateTime',
|
|
3391
|
+
description: 'Description',
|
|
3392
|
+
dynamicRouteId: 'DynamicRouteId',
|
|
3393
|
+
dynamicRouteType: 'DynamicRouteType',
|
|
3394
|
+
name: 'Name',
|
|
3395
|
+
nextHop: 'NextHop',
|
|
3396
|
+
priority: 'Priority',
|
|
3397
|
+
regionIds: 'RegionIds',
|
|
3398
|
+
status: 'Status',
|
|
3399
|
+
tagIds: 'TagIds',
|
|
3400
|
+
};
|
|
3401
|
+
}
|
|
3402
|
+
static types() {
|
|
3403
|
+
return {
|
|
3404
|
+
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
3405
|
+
applicationType: 'string',
|
|
3406
|
+
createTime: 'string',
|
|
3407
|
+
description: 'string',
|
|
3408
|
+
dynamicRouteId: 'string',
|
|
3409
|
+
dynamicRouteType: 'string',
|
|
3410
|
+
name: 'string',
|
|
3411
|
+
nextHop: 'string',
|
|
3412
|
+
priority: 'number',
|
|
3413
|
+
regionIds: { 'type': 'array', 'itemType': 'string' },
|
|
3414
|
+
status: 'string',
|
|
3415
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
3416
|
+
};
|
|
3417
|
+
}
|
|
3418
|
+
}
|
|
3419
|
+
exports.GetDynamicRouteResponseBodyDynamicRoute = GetDynamicRouteResponseBodyDynamicRoute;
|
|
3420
|
+
class GetPrivateAccessApplicationResponseBodyApplicationPortRanges extends $tea.Model {
|
|
3421
|
+
constructor(map) {
|
|
3422
|
+
super(map);
|
|
3423
|
+
}
|
|
3424
|
+
static names() {
|
|
3425
|
+
return {
|
|
3426
|
+
begin: 'Begin',
|
|
3427
|
+
end: 'End',
|
|
3428
|
+
};
|
|
3429
|
+
}
|
|
3430
|
+
static types() {
|
|
3431
|
+
return {
|
|
3432
|
+
begin: 'number',
|
|
3433
|
+
end: 'number',
|
|
3434
|
+
};
|
|
3435
|
+
}
|
|
3436
|
+
}
|
|
3437
|
+
exports.GetPrivateAccessApplicationResponseBodyApplicationPortRanges = GetPrivateAccessApplicationResponseBodyApplicationPortRanges;
|
|
3438
|
+
class GetPrivateAccessApplicationResponseBodyApplication extends $tea.Model {
|
|
3439
|
+
constructor(map) {
|
|
3440
|
+
super(map);
|
|
3441
|
+
}
|
|
3442
|
+
static names() {
|
|
3443
|
+
return {
|
|
3444
|
+
addresses: 'Addresses',
|
|
3445
|
+
applicationId: 'ApplicationId',
|
|
3446
|
+
connectorIds: 'ConnectorIds',
|
|
3447
|
+
createTime: 'CreateTime',
|
|
3448
|
+
description: 'Description',
|
|
3449
|
+
name: 'Name',
|
|
3450
|
+
policyIds: 'PolicyIds',
|
|
3451
|
+
portRanges: 'PortRanges',
|
|
3452
|
+
protocol: 'Protocol',
|
|
3453
|
+
status: 'Status',
|
|
3454
|
+
tagIds: 'TagIds',
|
|
3455
|
+
};
|
|
3456
|
+
}
|
|
3457
|
+
static types() {
|
|
3458
|
+
return {
|
|
3459
|
+
addresses: { 'type': 'array', 'itemType': 'string' },
|
|
3460
|
+
applicationId: 'string',
|
|
3461
|
+
connectorIds: { 'type': 'array', 'itemType': 'string' },
|
|
3462
|
+
createTime: 'string',
|
|
3463
|
+
description: 'string',
|
|
3464
|
+
name: 'string',
|
|
3465
|
+
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
3466
|
+
portRanges: { 'type': 'array', 'itemType': GetPrivateAccessApplicationResponseBodyApplicationPortRanges },
|
|
3467
|
+
protocol: 'string',
|
|
3468
|
+
status: 'string',
|
|
3469
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
3470
|
+
};
|
|
3471
|
+
}
|
|
3472
|
+
}
|
|
3473
|
+
exports.GetPrivateAccessApplicationResponseBodyApplication = GetPrivateAccessApplicationResponseBodyApplication;
|
|
3474
|
+
class GetPrivateAccessPolicyResponseBodyPolicyCustomUserAttributes extends $tea.Model {
|
|
3475
|
+
constructor(map) {
|
|
3476
|
+
super(map);
|
|
3477
|
+
}
|
|
3478
|
+
static names() {
|
|
3479
|
+
return {
|
|
3480
|
+
idpId: 'IdpId',
|
|
3481
|
+
relation: 'Relation',
|
|
3482
|
+
userGroupType: 'UserGroupType',
|
|
3483
|
+
value: 'Value',
|
|
3484
|
+
};
|
|
3485
|
+
}
|
|
3486
|
+
static types() {
|
|
3487
|
+
return {
|
|
3488
|
+
idpId: 'number',
|
|
3489
|
+
relation: 'string',
|
|
3490
|
+
userGroupType: 'string',
|
|
3491
|
+
value: 'string',
|
|
3492
|
+
};
|
|
3493
|
+
}
|
|
3494
|
+
}
|
|
3495
|
+
exports.GetPrivateAccessPolicyResponseBodyPolicyCustomUserAttributes = GetPrivateAccessPolicyResponseBodyPolicyCustomUserAttributes;
|
|
3496
|
+
class GetPrivateAccessPolicyResponseBodyPolicy extends $tea.Model {
|
|
3497
|
+
constructor(map) {
|
|
3498
|
+
super(map);
|
|
3499
|
+
}
|
|
3500
|
+
static names() {
|
|
3501
|
+
return {
|
|
3502
|
+
applicationIds: 'ApplicationIds',
|
|
3503
|
+
applicationType: 'ApplicationType',
|
|
3504
|
+
createTime: 'CreateTime',
|
|
3505
|
+
customUserAttributes: 'CustomUserAttributes',
|
|
3506
|
+
description: 'Description',
|
|
3507
|
+
name: 'Name',
|
|
3508
|
+
policyAction: 'PolicyAction',
|
|
3509
|
+
policyId: 'PolicyId',
|
|
3510
|
+
priority: 'Priority',
|
|
3511
|
+
status: 'Status',
|
|
3512
|
+
tagIds: 'TagIds',
|
|
3513
|
+
userGroupIds: 'UserGroupIds',
|
|
3514
|
+
userGroupMode: 'UserGroupMode',
|
|
3515
|
+
};
|
|
3516
|
+
}
|
|
3517
|
+
static types() {
|
|
3518
|
+
return {
|
|
3519
|
+
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
3520
|
+
applicationType: 'string',
|
|
3521
|
+
createTime: 'string',
|
|
3522
|
+
customUserAttributes: { 'type': 'array', 'itemType': GetPrivateAccessPolicyResponseBodyPolicyCustomUserAttributes },
|
|
3523
|
+
description: 'string',
|
|
3524
|
+
name: 'string',
|
|
3525
|
+
policyAction: 'string',
|
|
3526
|
+
policyId: 'string',
|
|
3527
|
+
priority: 'number',
|
|
3528
|
+
status: 'string',
|
|
3529
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
3530
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
3531
|
+
userGroupMode: 'string',
|
|
3532
|
+
};
|
|
3533
|
+
}
|
|
3534
|
+
}
|
|
3535
|
+
exports.GetPrivateAccessPolicyResponseBodyPolicy = GetPrivateAccessPolicyResponseBodyPolicy;
|
|
3536
|
+
class GetRegistrationPolicyResponseBodyLimitDetailLimitCount extends $tea.Model {
|
|
3537
|
+
constructor(map) {
|
|
3538
|
+
super(map);
|
|
3539
|
+
}
|
|
3540
|
+
static names() {
|
|
3541
|
+
return {
|
|
3542
|
+
all: 'All',
|
|
3543
|
+
mobile: 'Mobile',
|
|
3544
|
+
PC: 'PC',
|
|
3545
|
+
};
|
|
3546
|
+
}
|
|
3547
|
+
static types() {
|
|
3548
|
+
return {
|
|
3549
|
+
all: 'number',
|
|
3550
|
+
mobile: 'number',
|
|
3551
|
+
PC: 'number',
|
|
3552
|
+
};
|
|
3553
|
+
}
|
|
3554
|
+
}
|
|
3555
|
+
exports.GetRegistrationPolicyResponseBodyLimitDetailLimitCount = GetRegistrationPolicyResponseBodyLimitDetailLimitCount;
|
|
3556
|
+
class GetRegistrationPolicyResponseBodyLimitDetail extends $tea.Model {
|
|
3557
|
+
constructor(map) {
|
|
3558
|
+
super(map);
|
|
3559
|
+
}
|
|
3560
|
+
static names() {
|
|
3561
|
+
return {
|
|
3562
|
+
deviceBelong: 'DeviceBelong',
|
|
3563
|
+
limitCount: 'LimitCount',
|
|
3564
|
+
limitType: 'LimitType',
|
|
3565
|
+
};
|
|
3566
|
+
}
|
|
3567
|
+
static types() {
|
|
3568
|
+
return {
|
|
3569
|
+
deviceBelong: 'string',
|
|
3570
|
+
limitCount: GetRegistrationPolicyResponseBodyLimitDetailLimitCount,
|
|
3571
|
+
limitType: 'string',
|
|
3572
|
+
};
|
|
3573
|
+
}
|
|
3574
|
+
}
|
|
3575
|
+
exports.GetRegistrationPolicyResponseBodyLimitDetail = GetRegistrationPolicyResponseBodyLimitDetail;
|
|
3576
|
+
class GetUserDeviceResponseBodyDeviceHistoryUsers extends $tea.Model {
|
|
3577
|
+
constructor(map) {
|
|
3578
|
+
super(map);
|
|
3579
|
+
}
|
|
3580
|
+
static names() {
|
|
3581
|
+
return {
|
|
3582
|
+
saseUserId: 'SaseUserId',
|
|
3583
|
+
username: 'Username',
|
|
3584
|
+
};
|
|
3585
|
+
}
|
|
3586
|
+
static types() {
|
|
3587
|
+
return {
|
|
3588
|
+
saseUserId: 'string',
|
|
3589
|
+
username: 'string',
|
|
3590
|
+
};
|
|
3591
|
+
}
|
|
3592
|
+
}
|
|
3593
|
+
exports.GetUserDeviceResponseBodyDeviceHistoryUsers = GetUserDeviceResponseBodyDeviceHistoryUsers;
|
|
3594
|
+
class GetUserDeviceResponseBodyDevice extends $tea.Model {
|
|
3595
|
+
constructor(map) {
|
|
3596
|
+
super(map);
|
|
3597
|
+
}
|
|
3598
|
+
static names() {
|
|
3599
|
+
return {
|
|
3600
|
+
appStatus: 'AppStatus',
|
|
3601
|
+
appVersion: 'AppVersion',
|
|
3602
|
+
CPU: 'CPU',
|
|
3603
|
+
createTime: 'CreateTime',
|
|
3604
|
+
department: 'Department',
|
|
3605
|
+
deviceBelong: 'DeviceBelong',
|
|
3606
|
+
deviceModel: 'DeviceModel',
|
|
3607
|
+
deviceStatus: 'DeviceStatus',
|
|
3608
|
+
deviceTag: 'DeviceTag',
|
|
3609
|
+
deviceType: 'DeviceType',
|
|
3610
|
+
deviceVersion: 'DeviceVersion',
|
|
3611
|
+
disk: 'Disk',
|
|
3612
|
+
dlpStatus: 'DlpStatus',
|
|
3613
|
+
historyUsers: 'HistoryUsers',
|
|
3614
|
+
hostname: 'Hostname',
|
|
3615
|
+
iaStatus: 'IaStatus',
|
|
3616
|
+
innerIP: 'InnerIP',
|
|
3617
|
+
mac: 'Mac',
|
|
3618
|
+
memory: 'Memory',
|
|
3619
|
+
nacStatus: 'NacStatus',
|
|
3620
|
+
paStatus: 'PaStatus',
|
|
3621
|
+
saseUserId: 'SaseUserId',
|
|
3622
|
+
sharingStatus: 'SharingStatus',
|
|
3623
|
+
srcIP: 'SrcIP',
|
|
3624
|
+
updateTime: 'UpdateTime',
|
|
3625
|
+
username: 'Username',
|
|
3626
|
+
};
|
|
3627
|
+
}
|
|
3628
|
+
static types() {
|
|
3629
|
+
return {
|
|
3630
|
+
appStatus: 'string',
|
|
3631
|
+
appVersion: 'string',
|
|
3632
|
+
CPU: 'string',
|
|
3633
|
+
createTime: 'string',
|
|
3634
|
+
department: 'string',
|
|
3635
|
+
deviceBelong: 'string',
|
|
3636
|
+
deviceModel: 'string',
|
|
3637
|
+
deviceStatus: 'string',
|
|
3638
|
+
deviceTag: 'string',
|
|
3639
|
+
deviceType: 'string',
|
|
3640
|
+
deviceVersion: 'string',
|
|
3641
|
+
disk: 'string',
|
|
3642
|
+
dlpStatus: 'string',
|
|
3643
|
+
historyUsers: { 'type': 'array', 'itemType': GetUserDeviceResponseBodyDeviceHistoryUsers },
|
|
3644
|
+
hostname: 'string',
|
|
3645
|
+
iaStatus: 'string',
|
|
3646
|
+
innerIP: 'string',
|
|
3647
|
+
mac: 'string',
|
|
3648
|
+
memory: 'string',
|
|
3649
|
+
nacStatus: 'string',
|
|
3650
|
+
paStatus: 'string',
|
|
3651
|
+
saseUserId: 'string',
|
|
3652
|
+
sharingStatus: 'boolean',
|
|
3653
|
+
srcIP: 'string',
|
|
3654
|
+
updateTime: 'string',
|
|
3655
|
+
username: 'string',
|
|
3656
|
+
};
|
|
3657
|
+
}
|
|
3658
|
+
}
|
|
3659
|
+
exports.GetUserDeviceResponseBodyDevice = GetUserDeviceResponseBodyDevice;
|
|
3660
|
+
class GetUserGroupResponseBodyUserGroupAttributes extends $tea.Model {
|
|
3661
|
+
constructor(map) {
|
|
3662
|
+
super(map);
|
|
3663
|
+
}
|
|
3664
|
+
static names() {
|
|
3665
|
+
return {
|
|
3666
|
+
idpId: 'IdpId',
|
|
3667
|
+
relation: 'Relation',
|
|
3668
|
+
userGroupType: 'UserGroupType',
|
|
3669
|
+
value: 'Value',
|
|
3670
|
+
};
|
|
3671
|
+
}
|
|
3672
|
+
static types() {
|
|
3673
|
+
return {
|
|
3674
|
+
idpId: 'number',
|
|
3675
|
+
relation: 'string',
|
|
3676
|
+
userGroupType: 'string',
|
|
3677
|
+
value: 'string',
|
|
3678
|
+
};
|
|
3679
|
+
}
|
|
3680
|
+
}
|
|
3681
|
+
exports.GetUserGroupResponseBodyUserGroupAttributes = GetUserGroupResponseBodyUserGroupAttributes;
|
|
3682
|
+
class GetUserGroupResponseBodyUserGroup extends $tea.Model {
|
|
3683
|
+
constructor(map) {
|
|
3684
|
+
super(map);
|
|
3685
|
+
}
|
|
3686
|
+
static names() {
|
|
3687
|
+
return {
|
|
3688
|
+
attributes: 'Attributes',
|
|
3689
|
+
createTime: 'CreateTime',
|
|
3690
|
+
description: 'Description',
|
|
3691
|
+
name: 'Name',
|
|
3692
|
+
userGroupId: 'UserGroupId',
|
|
3693
|
+
};
|
|
3694
|
+
}
|
|
3695
|
+
static types() {
|
|
3696
|
+
return {
|
|
3697
|
+
attributes: { 'type': 'array', 'itemType': GetUserGroupResponseBodyUserGroupAttributes },
|
|
3698
|
+
createTime: 'string',
|
|
3699
|
+
description: 'string',
|
|
3700
|
+
name: 'string',
|
|
3701
|
+
userGroupId: 'string',
|
|
3702
|
+
};
|
|
3703
|
+
}
|
|
3704
|
+
}
|
|
3705
|
+
exports.GetUserGroupResponseBodyUserGroup = GetUserGroupResponseBodyUserGroup;
|
|
3706
|
+
class ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplicationsPortRanges extends $tea.Model {
|
|
3707
|
+
constructor(map) {
|
|
3708
|
+
super(map);
|
|
3709
|
+
}
|
|
3710
|
+
static names() {
|
|
3711
|
+
return {
|
|
3712
|
+
begin: 'Begin',
|
|
3713
|
+
end: 'End',
|
|
3714
|
+
};
|
|
3715
|
+
}
|
|
3716
|
+
static types() {
|
|
3717
|
+
return {
|
|
3718
|
+
begin: 'number',
|
|
3719
|
+
end: 'number',
|
|
3720
|
+
};
|
|
3721
|
+
}
|
|
3722
|
+
}
|
|
3723
|
+
exports.ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplicationsPortRanges = ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplicationsPortRanges;
|
|
3724
|
+
class ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplications extends $tea.Model {
|
|
3725
|
+
constructor(map) {
|
|
3726
|
+
super(map);
|
|
3727
|
+
}
|
|
3728
|
+
static names() {
|
|
3729
|
+
return {
|
|
3730
|
+
addresses: 'Addresses',
|
|
3731
|
+
applicationId: 'ApplicationId',
|
|
3732
|
+
createTime: 'CreateTime',
|
|
3733
|
+
description: 'Description',
|
|
3734
|
+
name: 'Name',
|
|
3735
|
+
portRanges: 'PortRanges',
|
|
3736
|
+
protocol: 'Protocol',
|
|
3737
|
+
status: 'Status',
|
|
3738
|
+
};
|
|
3739
|
+
}
|
|
3740
|
+
static types() {
|
|
3741
|
+
return {
|
|
3742
|
+
addresses: { 'type': 'array', 'itemType': 'string' },
|
|
3743
|
+
applicationId: 'string',
|
|
3744
|
+
createTime: 'string',
|
|
3745
|
+
description: 'string',
|
|
3746
|
+
name: 'string',
|
|
3747
|
+
portRanges: { 'type': 'array', 'itemType': ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplicationsPortRanges },
|
|
3748
|
+
protocol: 'string',
|
|
3749
|
+
status: 'string',
|
|
3750
|
+
};
|
|
3751
|
+
}
|
|
3752
|
+
}
|
|
3753
|
+
exports.ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplications = ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplications;
|
|
3754
|
+
class ListApplicationsForPrivateAccessPolicyResponseBodyPolices extends $tea.Model {
|
|
3755
|
+
constructor(map) {
|
|
3756
|
+
super(map);
|
|
3757
|
+
}
|
|
3758
|
+
static names() {
|
|
3759
|
+
return {
|
|
3760
|
+
applications: 'Applications',
|
|
3761
|
+
policyId: 'PolicyId',
|
|
3762
|
+
};
|
|
3763
|
+
}
|
|
3764
|
+
static types() {
|
|
3765
|
+
return {
|
|
3766
|
+
applications: { 'type': 'array', 'itemType': ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplications },
|
|
3767
|
+
policyId: 'string',
|
|
3768
|
+
};
|
|
3769
|
+
}
|
|
3770
|
+
}
|
|
3771
|
+
exports.ListApplicationsForPrivateAccessPolicyResponseBodyPolices = ListApplicationsForPrivateAccessPolicyResponseBodyPolices;
|
|
3772
|
+
class ListApplicationsForPrivateAccessTagResponseBodyTagsApplicationsPortRanges extends $tea.Model {
|
|
3773
|
+
constructor(map) {
|
|
3774
|
+
super(map);
|
|
3775
|
+
}
|
|
3776
|
+
static names() {
|
|
3777
|
+
return {
|
|
3778
|
+
begin: 'Begin',
|
|
3779
|
+
end: 'End',
|
|
3780
|
+
};
|
|
3781
|
+
}
|
|
3782
|
+
static types() {
|
|
3783
|
+
return {
|
|
3784
|
+
begin: 'number',
|
|
3785
|
+
end: 'number',
|
|
3786
|
+
};
|
|
3787
|
+
}
|
|
3788
|
+
}
|
|
3789
|
+
exports.ListApplicationsForPrivateAccessTagResponseBodyTagsApplicationsPortRanges = ListApplicationsForPrivateAccessTagResponseBodyTagsApplicationsPortRanges;
|
|
3790
|
+
class ListApplicationsForPrivateAccessTagResponseBodyTagsApplications extends $tea.Model {
|
|
3791
|
+
constructor(map) {
|
|
3792
|
+
super(map);
|
|
3793
|
+
}
|
|
3794
|
+
static names() {
|
|
3795
|
+
return {
|
|
3796
|
+
addresses: 'Addresses',
|
|
3797
|
+
applicationId: 'ApplicationId',
|
|
3798
|
+
createTime: 'CreateTime',
|
|
3799
|
+
description: 'Description',
|
|
3800
|
+
name: 'Name',
|
|
3801
|
+
portRanges: 'PortRanges',
|
|
3802
|
+
protocol: 'Protocol',
|
|
3803
|
+
status: 'Status',
|
|
3804
|
+
};
|
|
3805
|
+
}
|
|
3806
|
+
static types() {
|
|
3807
|
+
return {
|
|
3808
|
+
addresses: { 'type': 'array', 'itemType': 'string' },
|
|
3809
|
+
applicationId: 'string',
|
|
3810
|
+
createTime: 'string',
|
|
3811
|
+
description: 'string',
|
|
3812
|
+
name: 'string',
|
|
3813
|
+
portRanges: { 'type': 'array', 'itemType': ListApplicationsForPrivateAccessTagResponseBodyTagsApplicationsPortRanges },
|
|
3814
|
+
protocol: 'string',
|
|
3815
|
+
status: 'string',
|
|
3816
|
+
};
|
|
3817
|
+
}
|
|
3818
|
+
}
|
|
3819
|
+
exports.ListApplicationsForPrivateAccessTagResponseBodyTagsApplications = ListApplicationsForPrivateAccessTagResponseBodyTagsApplications;
|
|
3820
|
+
class ListApplicationsForPrivateAccessTagResponseBodyTags extends $tea.Model {
|
|
3821
|
+
constructor(map) {
|
|
3822
|
+
super(map);
|
|
3823
|
+
}
|
|
3824
|
+
static names() {
|
|
3825
|
+
return {
|
|
3826
|
+
applications: 'Applications',
|
|
3827
|
+
tagId: 'TagId',
|
|
3828
|
+
};
|
|
3829
|
+
}
|
|
3830
|
+
static types() {
|
|
3831
|
+
return {
|
|
3832
|
+
applications: { 'type': 'array', 'itemType': ListApplicationsForPrivateAccessTagResponseBodyTagsApplications },
|
|
3833
|
+
tagId: 'string',
|
|
3834
|
+
};
|
|
3835
|
+
}
|
|
3836
|
+
}
|
|
3837
|
+
exports.ListApplicationsForPrivateAccessTagResponseBodyTags = ListApplicationsForPrivateAccessTagResponseBodyTags;
|
|
3838
|
+
class ListConnectorsResponseBodyConnectorsApplications extends $tea.Model {
|
|
3839
|
+
constructor(map) {
|
|
3840
|
+
super(map);
|
|
3841
|
+
}
|
|
3842
|
+
static names() {
|
|
3843
|
+
return {
|
|
3844
|
+
applicationId: 'ApplicationId',
|
|
3845
|
+
applicationName: 'ApplicationName',
|
|
3846
|
+
};
|
|
3847
|
+
}
|
|
3848
|
+
static types() {
|
|
3849
|
+
return {
|
|
3850
|
+
applicationId: 'string',
|
|
3851
|
+
applicationName: 'string',
|
|
3852
|
+
};
|
|
3853
|
+
}
|
|
3854
|
+
}
|
|
3855
|
+
exports.ListConnectorsResponseBodyConnectorsApplications = ListConnectorsResponseBodyConnectorsApplications;
|
|
3856
|
+
class ListConnectorsResponseBodyConnectorsConnectorClients extends $tea.Model {
|
|
3857
|
+
constructor(map) {
|
|
3858
|
+
super(map);
|
|
3859
|
+
}
|
|
3860
|
+
static names() {
|
|
3861
|
+
return {
|
|
3862
|
+
connectionStatus: 'ConnectionStatus',
|
|
3863
|
+
devTag: 'DevTag',
|
|
3864
|
+
hostname: 'Hostname',
|
|
3865
|
+
publicIp: 'PublicIp',
|
|
3866
|
+
};
|
|
3867
|
+
}
|
|
3868
|
+
static types() {
|
|
3869
|
+
return {
|
|
3870
|
+
connectionStatus: 'string',
|
|
3871
|
+
devTag: 'string',
|
|
3872
|
+
hostname: 'string',
|
|
3873
|
+
publicIp: 'string',
|
|
3874
|
+
};
|
|
3875
|
+
}
|
|
3876
|
+
}
|
|
3877
|
+
exports.ListConnectorsResponseBodyConnectorsConnectorClients = ListConnectorsResponseBodyConnectorsConnectorClients;
|
|
3878
|
+
class ListConnectorsResponseBodyConnectorsUpgradeTime extends $tea.Model {
|
|
3879
|
+
constructor(map) {
|
|
3880
|
+
super(map);
|
|
3881
|
+
}
|
|
3882
|
+
static names() {
|
|
3883
|
+
return {
|
|
3884
|
+
end: 'End',
|
|
3885
|
+
start: 'Start',
|
|
3886
|
+
};
|
|
3887
|
+
}
|
|
3888
|
+
static types() {
|
|
3889
|
+
return {
|
|
3890
|
+
end: 'string',
|
|
3891
|
+
start: 'string',
|
|
3892
|
+
};
|
|
3893
|
+
}
|
|
3894
|
+
}
|
|
3895
|
+
exports.ListConnectorsResponseBodyConnectorsUpgradeTime = ListConnectorsResponseBodyConnectorsUpgradeTime;
|
|
3896
|
+
class ListConnectorsResponseBodyConnectors extends $tea.Model {
|
|
3897
|
+
constructor(map) {
|
|
3898
|
+
super(map);
|
|
3899
|
+
}
|
|
3900
|
+
static names() {
|
|
3901
|
+
return {
|
|
3902
|
+
applications: 'Applications',
|
|
3903
|
+
connectorClients: 'ConnectorClients',
|
|
3904
|
+
connectorId: 'ConnectorId',
|
|
3905
|
+
createTime: 'CreateTime',
|
|
3906
|
+
name: 'Name',
|
|
3907
|
+
regionId: 'RegionId',
|
|
3908
|
+
status: 'Status',
|
|
3909
|
+
switchStatus: 'SwitchStatus',
|
|
3910
|
+
upgradeTime: 'UpgradeTime',
|
|
3911
|
+
};
|
|
3912
|
+
}
|
|
3913
|
+
static types() {
|
|
3914
|
+
return {
|
|
3915
|
+
applications: { 'type': 'array', 'itemType': ListConnectorsResponseBodyConnectorsApplications },
|
|
3916
|
+
connectorClients: { 'type': 'array', 'itemType': ListConnectorsResponseBodyConnectorsConnectorClients },
|
|
3917
|
+
connectorId: 'string',
|
|
3918
|
+
createTime: 'string',
|
|
3919
|
+
name: 'string',
|
|
3920
|
+
regionId: 'string',
|
|
3921
|
+
status: 'string',
|
|
3922
|
+
switchStatus: 'string',
|
|
3923
|
+
upgradeTime: ListConnectorsResponseBodyConnectorsUpgradeTime,
|
|
3924
|
+
};
|
|
3925
|
+
}
|
|
3926
|
+
}
|
|
3927
|
+
exports.ListConnectorsResponseBodyConnectors = ListConnectorsResponseBodyConnectors;
|
|
3928
|
+
class ListDynamicRoutesResponseBodyDynamicRoutes extends $tea.Model {
|
|
3929
|
+
constructor(map) {
|
|
3930
|
+
super(map);
|
|
3931
|
+
}
|
|
3932
|
+
static names() {
|
|
3933
|
+
return {
|
|
3934
|
+
applicationIds: 'ApplicationIds',
|
|
3935
|
+
applicationType: 'ApplicationType',
|
|
3936
|
+
createTime: 'CreateTime',
|
|
3937
|
+
description: 'Description',
|
|
3938
|
+
dynamicRouteId: 'DynamicRouteId',
|
|
3939
|
+
dynamicRouteType: 'DynamicRouteType',
|
|
3940
|
+
name: 'Name',
|
|
3941
|
+
nextHop: 'NextHop',
|
|
3942
|
+
priority: 'Priority',
|
|
3943
|
+
regionIds: 'RegionIds',
|
|
3944
|
+
status: 'Status',
|
|
3945
|
+
tagIds: 'TagIds',
|
|
3946
|
+
};
|
|
3947
|
+
}
|
|
3948
|
+
static types() {
|
|
3949
|
+
return {
|
|
3950
|
+
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
3951
|
+
applicationType: 'string',
|
|
3952
|
+
createTime: 'string',
|
|
3953
|
+
description: 'string',
|
|
3954
|
+
dynamicRouteId: 'string',
|
|
3955
|
+
dynamicRouteType: 'string',
|
|
3956
|
+
name: 'string',
|
|
3957
|
+
nextHop: 'string',
|
|
3958
|
+
priority: 'number',
|
|
3959
|
+
regionIds: { 'type': 'array', 'itemType': 'string' },
|
|
3960
|
+
status: 'string',
|
|
3961
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
3962
|
+
};
|
|
3963
|
+
}
|
|
3964
|
+
}
|
|
3965
|
+
exports.ListDynamicRoutesResponseBodyDynamicRoutes = ListDynamicRoutesResponseBodyDynamicRoutes;
|
|
3966
|
+
class ListExcessiveDeviceRegistrationApplicationsResponseBodyApplications extends $tea.Model {
|
|
3967
|
+
constructor(map) {
|
|
3968
|
+
super(map);
|
|
3969
|
+
}
|
|
3970
|
+
static names() {
|
|
3971
|
+
return {
|
|
3972
|
+
applicationId: 'ApplicationId',
|
|
3973
|
+
createTime: 'CreateTime',
|
|
3974
|
+
department: 'Department',
|
|
3975
|
+
description: 'Description',
|
|
3976
|
+
deviceTag: 'DeviceTag',
|
|
3977
|
+
deviceType: 'DeviceType',
|
|
3978
|
+
hostname: 'Hostname',
|
|
3979
|
+
isUsed: 'IsUsed',
|
|
3980
|
+
mac: 'Mac',
|
|
3981
|
+
saseUserId: 'SaseUserId',
|
|
3982
|
+
status: 'Status',
|
|
3983
|
+
username: 'Username',
|
|
3984
|
+
};
|
|
3985
|
+
}
|
|
3986
|
+
static types() {
|
|
3987
|
+
return {
|
|
3988
|
+
applicationId: 'string',
|
|
3989
|
+
createTime: 'string',
|
|
3990
|
+
department: 'string',
|
|
3991
|
+
description: 'string',
|
|
3992
|
+
deviceTag: 'string',
|
|
3993
|
+
deviceType: 'string',
|
|
3994
|
+
hostname: 'string',
|
|
3995
|
+
isUsed: 'boolean',
|
|
3996
|
+
mac: 'string',
|
|
3997
|
+
saseUserId: 'string',
|
|
3998
|
+
status: 'string',
|
|
3999
|
+
username: 'string',
|
|
4000
|
+
};
|
|
4001
|
+
}
|
|
4002
|
+
}
|
|
4003
|
+
exports.ListExcessiveDeviceRegistrationApplicationsResponseBodyApplications = ListExcessiveDeviceRegistrationApplicationsResponseBodyApplications;
|
|
4004
|
+
class ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPoliciesCustomUserAttributes extends $tea.Model {
|
|
4005
|
+
constructor(map) {
|
|
4006
|
+
super(map);
|
|
4007
|
+
}
|
|
4008
|
+
static names() {
|
|
4009
|
+
return {
|
|
4010
|
+
idpId: 'IdpId',
|
|
4011
|
+
relation: 'Relation',
|
|
4012
|
+
userGroupType: 'UserGroupType',
|
|
4013
|
+
value: 'Value',
|
|
4014
|
+
};
|
|
4015
|
+
}
|
|
4016
|
+
static types() {
|
|
4017
|
+
return {
|
|
4018
|
+
idpId: 'number',
|
|
4019
|
+
relation: 'string',
|
|
4020
|
+
userGroupType: 'string',
|
|
4021
|
+
value: 'string',
|
|
4022
|
+
};
|
|
4023
|
+
}
|
|
4024
|
+
}
|
|
4025
|
+
exports.ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPoliciesCustomUserAttributes = ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPoliciesCustomUserAttributes;
|
|
4026
|
+
class ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPolicies extends $tea.Model {
|
|
4027
|
+
constructor(map) {
|
|
4028
|
+
super(map);
|
|
4029
|
+
}
|
|
4030
|
+
static names() {
|
|
4031
|
+
return {
|
|
4032
|
+
applicationType: 'ApplicationType',
|
|
4033
|
+
createTime: 'CreateTime',
|
|
4034
|
+
customUserAttributes: 'CustomUserAttributes',
|
|
4035
|
+
description: 'Description',
|
|
4036
|
+
name: 'Name',
|
|
4037
|
+
policyAction: 'PolicyAction',
|
|
4038
|
+
policyId: 'PolicyId',
|
|
4039
|
+
priority: 'Priority',
|
|
4040
|
+
status: 'Status',
|
|
4041
|
+
userGroupType: 'UserGroupType',
|
|
4042
|
+
};
|
|
4043
|
+
}
|
|
4044
|
+
static types() {
|
|
4045
|
+
return {
|
|
4046
|
+
applicationType: 'string',
|
|
4047
|
+
createTime: 'string',
|
|
4048
|
+
customUserAttributes: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPoliciesCustomUserAttributes },
|
|
4049
|
+
description: 'string',
|
|
4050
|
+
name: 'string',
|
|
4051
|
+
policyAction: 'string',
|
|
4052
|
+
policyId: 'string',
|
|
4053
|
+
priority: 'number',
|
|
4054
|
+
status: 'string',
|
|
4055
|
+
userGroupType: 'string',
|
|
4056
|
+
};
|
|
4057
|
+
}
|
|
4058
|
+
}
|
|
4059
|
+
exports.ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPolicies = ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPolicies;
|
|
4060
|
+
class ListPolicesForPrivateAccessApplicationResponseBodyApplications extends $tea.Model {
|
|
4061
|
+
constructor(map) {
|
|
4062
|
+
super(map);
|
|
4063
|
+
}
|
|
4064
|
+
static names() {
|
|
4065
|
+
return {
|
|
4066
|
+
applicationId: 'ApplicationId',
|
|
4067
|
+
policies: 'Policies',
|
|
4068
|
+
};
|
|
4069
|
+
}
|
|
4070
|
+
static types() {
|
|
4071
|
+
return {
|
|
2371
4072
|
applicationId: 'string',
|
|
2372
|
-
|
|
2373
|
-
description: 'string',
|
|
2374
|
-
name: 'string',
|
|
2375
|
-
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
2376
|
-
portRanges: { 'type': 'array', 'itemType': GetPrivateAccessApplicationResponseBodyApplicationPortRanges },
|
|
2377
|
-
protocol: 'string',
|
|
2378
|
-
status: 'string',
|
|
2379
|
-
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
4073
|
+
policies: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPolicies },
|
|
2380
4074
|
};
|
|
2381
4075
|
}
|
|
2382
4076
|
}
|
|
2383
|
-
exports.
|
|
2384
|
-
class
|
|
4077
|
+
exports.ListPolicesForPrivateAccessApplicationResponseBodyApplications = ListPolicesForPrivateAccessApplicationResponseBodyApplications;
|
|
4078
|
+
class ListPolicesForPrivateAccessTagResponseBodyTagsPolicesCustomUserAttributes extends $tea.Model {
|
|
2385
4079
|
constructor(map) {
|
|
2386
4080
|
super(map);
|
|
2387
4081
|
}
|
|
@@ -2402,14 +4096,13 @@ class GetPrivateAccessPolicyResponseBodyPolicyCustomUserAttributes extends $tea.
|
|
|
2402
4096
|
};
|
|
2403
4097
|
}
|
|
2404
4098
|
}
|
|
2405
|
-
exports.
|
|
2406
|
-
class
|
|
4099
|
+
exports.ListPolicesForPrivateAccessTagResponseBodyTagsPolicesCustomUserAttributes = ListPolicesForPrivateAccessTagResponseBodyTagsPolicesCustomUserAttributes;
|
|
4100
|
+
class ListPolicesForPrivateAccessTagResponseBodyTagsPolices extends $tea.Model {
|
|
2407
4101
|
constructor(map) {
|
|
2408
4102
|
super(map);
|
|
2409
4103
|
}
|
|
2410
4104
|
static names() {
|
|
2411
4105
|
return {
|
|
2412
|
-
applicationIds: 'ApplicationIds',
|
|
2413
4106
|
applicationType: 'ApplicationType',
|
|
2414
4107
|
createTime: 'CreateTime',
|
|
2415
4108
|
customUserAttributes: 'CustomUserAttributes',
|
|
@@ -2419,77 +4112,82 @@ class GetPrivateAccessPolicyResponseBodyPolicy extends $tea.Model {
|
|
|
2419
4112
|
policyId: 'PolicyId',
|
|
2420
4113
|
priority: 'Priority',
|
|
2421
4114
|
status: 'Status',
|
|
2422
|
-
|
|
2423
|
-
userGroupIds: 'UserGroupIds',
|
|
2424
|
-
userGroupMode: 'UserGroupMode',
|
|
4115
|
+
userGroupType: 'UserGroupType',
|
|
2425
4116
|
};
|
|
2426
4117
|
}
|
|
2427
4118
|
static types() {
|
|
2428
4119
|
return {
|
|
2429
|
-
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
2430
4120
|
applicationType: 'string',
|
|
2431
4121
|
createTime: 'string',
|
|
2432
|
-
customUserAttributes: { 'type': 'array', 'itemType':
|
|
4122
|
+
customUserAttributes: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessTagResponseBodyTagsPolicesCustomUserAttributes },
|
|
2433
4123
|
description: 'string',
|
|
2434
4124
|
name: 'string',
|
|
2435
4125
|
policyAction: 'string',
|
|
2436
4126
|
policyId: 'string',
|
|
2437
4127
|
priority: 'number',
|
|
2438
4128
|
status: 'string',
|
|
2439
|
-
|
|
2440
|
-
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
2441
|
-
userGroupMode: 'string',
|
|
4129
|
+
userGroupType: 'string',
|
|
2442
4130
|
};
|
|
2443
4131
|
}
|
|
2444
4132
|
}
|
|
2445
|
-
exports.
|
|
2446
|
-
class
|
|
4133
|
+
exports.ListPolicesForPrivateAccessTagResponseBodyTagsPolices = ListPolicesForPrivateAccessTagResponseBodyTagsPolices;
|
|
4134
|
+
class ListPolicesForPrivateAccessTagResponseBodyTags extends $tea.Model {
|
|
2447
4135
|
constructor(map) {
|
|
2448
4136
|
super(map);
|
|
2449
4137
|
}
|
|
2450
4138
|
static names() {
|
|
2451
4139
|
return {
|
|
2452
|
-
|
|
2453
|
-
|
|
2454
|
-
userGroupType: 'UserGroupType',
|
|
2455
|
-
value: 'Value',
|
|
4140
|
+
polices: 'Polices',
|
|
4141
|
+
tagId: 'TagId',
|
|
2456
4142
|
};
|
|
2457
4143
|
}
|
|
2458
4144
|
static types() {
|
|
2459
4145
|
return {
|
|
2460
|
-
|
|
2461
|
-
|
|
2462
|
-
userGroupType: 'string',
|
|
2463
|
-
value: 'string',
|
|
4146
|
+
polices: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessTagResponseBodyTagsPolices },
|
|
4147
|
+
tagId: 'string',
|
|
2464
4148
|
};
|
|
2465
4149
|
}
|
|
2466
4150
|
}
|
|
2467
|
-
exports.
|
|
2468
|
-
class
|
|
4151
|
+
exports.ListPolicesForPrivateAccessTagResponseBodyTags = ListPolicesForPrivateAccessTagResponseBodyTags;
|
|
4152
|
+
class ListPolicesForUserGroupResponseBodyUserGroupsPolices extends $tea.Model {
|
|
2469
4153
|
constructor(map) {
|
|
2470
4154
|
super(map);
|
|
2471
4155
|
}
|
|
2472
4156
|
static names() {
|
|
2473
4157
|
return {
|
|
2474
|
-
attributes: 'Attributes',
|
|
2475
|
-
createTime: 'CreateTime',
|
|
2476
|
-
description: 'Description',
|
|
2477
4158
|
name: 'Name',
|
|
2478
|
-
|
|
4159
|
+
policyId: 'PolicyId',
|
|
4160
|
+
policyType: 'PolicyType',
|
|
2479
4161
|
};
|
|
2480
4162
|
}
|
|
2481
4163
|
static types() {
|
|
2482
4164
|
return {
|
|
2483
|
-
attributes: { 'type': 'array', 'itemType': GetUserGroupResponseBodyUserGroupAttributes },
|
|
2484
|
-
createTime: 'string',
|
|
2485
|
-
description: 'string',
|
|
2486
4165
|
name: 'string',
|
|
4166
|
+
policyId: 'string',
|
|
4167
|
+
policyType: 'string',
|
|
4168
|
+
};
|
|
4169
|
+
}
|
|
4170
|
+
}
|
|
4171
|
+
exports.ListPolicesForUserGroupResponseBodyUserGroupsPolices = ListPolicesForUserGroupResponseBodyUserGroupsPolices;
|
|
4172
|
+
class ListPolicesForUserGroupResponseBodyUserGroups extends $tea.Model {
|
|
4173
|
+
constructor(map) {
|
|
4174
|
+
super(map);
|
|
4175
|
+
}
|
|
4176
|
+
static names() {
|
|
4177
|
+
return {
|
|
4178
|
+
polices: 'Polices',
|
|
4179
|
+
userGroupId: 'UserGroupId',
|
|
4180
|
+
};
|
|
4181
|
+
}
|
|
4182
|
+
static types() {
|
|
4183
|
+
return {
|
|
4184
|
+
polices: { 'type': 'array', 'itemType': ListPolicesForUserGroupResponseBodyUserGroupsPolices },
|
|
2487
4185
|
userGroupId: 'string',
|
|
2488
4186
|
};
|
|
2489
4187
|
}
|
|
2490
4188
|
}
|
|
2491
|
-
exports.
|
|
2492
|
-
class
|
|
4189
|
+
exports.ListPolicesForUserGroupResponseBodyUserGroups = ListPolicesForUserGroupResponseBodyUserGroups;
|
|
4190
|
+
class ListPrivateAccessApplicationsResponseBodyApplicationsPortRanges extends $tea.Model {
|
|
2493
4191
|
constructor(map) {
|
|
2494
4192
|
super(map);
|
|
2495
4193
|
}
|
|
@@ -2506,8 +4204,8 @@ class ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplicationsPortR
|
|
|
2506
4204
|
};
|
|
2507
4205
|
}
|
|
2508
4206
|
}
|
|
2509
|
-
exports.
|
|
2510
|
-
class
|
|
4207
|
+
exports.ListPrivateAccessApplicationsResponseBodyApplicationsPortRanges = ListPrivateAccessApplicationsResponseBodyApplicationsPortRanges;
|
|
4208
|
+
class ListPrivateAccessApplicationsResponseBodyApplications extends $tea.Model {
|
|
2511
4209
|
constructor(map) {
|
|
2512
4210
|
super(map);
|
|
2513
4211
|
}
|
|
@@ -2515,47 +4213,35 @@ class ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplications exte
|
|
|
2515
4213
|
return {
|
|
2516
4214
|
addresses: 'Addresses',
|
|
2517
4215
|
applicationId: 'ApplicationId',
|
|
4216
|
+
connectorIds: 'ConnectorIds',
|
|
2518
4217
|
createTime: 'CreateTime',
|
|
2519
4218
|
description: 'Description',
|
|
2520
4219
|
name: 'Name',
|
|
4220
|
+
policyIds: 'PolicyIds',
|
|
2521
4221
|
portRanges: 'PortRanges',
|
|
2522
4222
|
protocol: 'Protocol',
|
|
2523
4223
|
status: 'Status',
|
|
4224
|
+
tagIds: 'TagIds',
|
|
2524
4225
|
};
|
|
2525
4226
|
}
|
|
2526
4227
|
static types() {
|
|
2527
4228
|
return {
|
|
2528
4229
|
addresses: { 'type': 'array', 'itemType': 'string' },
|
|
2529
4230
|
applicationId: 'string',
|
|
4231
|
+
connectorIds: { 'type': 'array', 'itemType': 'string' },
|
|
2530
4232
|
createTime: 'string',
|
|
2531
4233
|
description: 'string',
|
|
2532
4234
|
name: 'string',
|
|
2533
|
-
|
|
4235
|
+
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
4236
|
+
portRanges: { 'type': 'array', 'itemType': ListPrivateAccessApplicationsResponseBodyApplicationsPortRanges },
|
|
2534
4237
|
protocol: 'string',
|
|
2535
4238
|
status: 'string',
|
|
4239
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
2536
4240
|
};
|
|
2537
4241
|
}
|
|
2538
4242
|
}
|
|
2539
|
-
exports.
|
|
2540
|
-
class
|
|
2541
|
-
constructor(map) {
|
|
2542
|
-
super(map);
|
|
2543
|
-
}
|
|
2544
|
-
static names() {
|
|
2545
|
-
return {
|
|
2546
|
-
applications: 'Applications',
|
|
2547
|
-
policyId: 'PolicyId',
|
|
2548
|
-
};
|
|
2549
|
-
}
|
|
2550
|
-
static types() {
|
|
2551
|
-
return {
|
|
2552
|
-
applications: { 'type': 'array', 'itemType': ListApplicationsForPrivateAccessPolicyResponseBodyPolicesApplications },
|
|
2553
|
-
policyId: 'string',
|
|
2554
|
-
};
|
|
2555
|
-
}
|
|
2556
|
-
}
|
|
2557
|
-
exports.ListApplicationsForPrivateAccessPolicyResponseBodyPolices = ListApplicationsForPrivateAccessPolicyResponseBodyPolices;
|
|
2558
|
-
class ListApplicationsForPrivateAccessTagResponseBodyTagsApplicationsPortRanges extends $tea.Model {
|
|
4243
|
+
exports.ListPrivateAccessApplicationsResponseBodyApplications = ListPrivateAccessApplicationsResponseBodyApplications;
|
|
4244
|
+
class ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutesApplicationsPortRanges extends $tea.Model {
|
|
2559
4245
|
constructor(map) {
|
|
2560
4246
|
super(map);
|
|
2561
4247
|
}
|
|
@@ -2572,8 +4258,8 @@ class ListApplicationsForPrivateAccessTagResponseBodyTagsApplicationsPortRanges
|
|
|
2572
4258
|
};
|
|
2573
4259
|
}
|
|
2574
4260
|
}
|
|
2575
|
-
exports.
|
|
2576
|
-
class
|
|
4261
|
+
exports.ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutesApplicationsPortRanges = ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutesApplicationsPortRanges;
|
|
4262
|
+
class ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutesApplications extends $tea.Model {
|
|
2577
4263
|
constructor(map) {
|
|
2578
4264
|
super(map);
|
|
2579
4265
|
}
|
|
@@ -2596,440 +4282,498 @@ class ListApplicationsForPrivateAccessTagResponseBodyTagsApplications extends $t
|
|
|
2596
4282
|
createTime: 'string',
|
|
2597
4283
|
description: 'string',
|
|
2598
4284
|
name: 'string',
|
|
2599
|
-
portRanges: { 'type': 'array', 'itemType':
|
|
4285
|
+
portRanges: { 'type': 'array', 'itemType': ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutesApplicationsPortRanges },
|
|
2600
4286
|
protocol: 'string',
|
|
2601
4287
|
status: 'string',
|
|
2602
4288
|
};
|
|
2603
4289
|
}
|
|
2604
4290
|
}
|
|
2605
|
-
exports.
|
|
2606
|
-
class
|
|
4291
|
+
exports.ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutesApplications = ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutesApplications;
|
|
4292
|
+
class ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutes extends $tea.Model {
|
|
2607
4293
|
constructor(map) {
|
|
2608
4294
|
super(map);
|
|
2609
4295
|
}
|
|
2610
4296
|
static names() {
|
|
2611
4297
|
return {
|
|
2612
4298
|
applications: 'Applications',
|
|
2613
|
-
|
|
2614
|
-
};
|
|
2615
|
-
}
|
|
2616
|
-
static types() {
|
|
2617
|
-
return {
|
|
2618
|
-
applications: { 'type': 'array', 'itemType': ListApplicationsForPrivateAccessTagResponseBodyTagsApplications },
|
|
2619
|
-
tagId: 'string',
|
|
2620
|
-
};
|
|
2621
|
-
}
|
|
2622
|
-
}
|
|
2623
|
-
exports.ListApplicationsForPrivateAccessTagResponseBodyTags = ListApplicationsForPrivateAccessTagResponseBodyTags;
|
|
2624
|
-
class ListConnectorsResponseBodyConnectorsApplications extends $tea.Model {
|
|
2625
|
-
constructor(map) {
|
|
2626
|
-
super(map);
|
|
2627
|
-
}
|
|
2628
|
-
static names() {
|
|
2629
|
-
return {
|
|
2630
|
-
applicationId: 'ApplicationId',
|
|
2631
|
-
applicationName: 'ApplicationName',
|
|
4299
|
+
dynamicRouteId: 'DynamicRouteId',
|
|
2632
4300
|
};
|
|
2633
4301
|
}
|
|
2634
4302
|
static types() {
|
|
2635
4303
|
return {
|
|
2636
|
-
|
|
2637
|
-
|
|
4304
|
+
applications: { 'type': 'array', 'itemType': ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutesApplications },
|
|
4305
|
+
dynamicRouteId: 'string',
|
|
2638
4306
|
};
|
|
2639
4307
|
}
|
|
2640
4308
|
}
|
|
2641
|
-
exports.
|
|
2642
|
-
class
|
|
4309
|
+
exports.ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutes = ListPrivateAccessApplicationsForDynamicRouteResponseBodyDynamicRoutes;
|
|
4310
|
+
class ListPrivateAccessPolicesResponseBodyPolicesCustomUserAttributes extends $tea.Model {
|
|
2643
4311
|
constructor(map) {
|
|
2644
4312
|
super(map);
|
|
2645
4313
|
}
|
|
2646
4314
|
static names() {
|
|
2647
4315
|
return {
|
|
2648
|
-
|
|
2649
|
-
|
|
4316
|
+
idpId: 'IdpId',
|
|
4317
|
+
relation: 'Relation',
|
|
4318
|
+
userGroupType: 'UserGroupType',
|
|
4319
|
+
value: 'Value',
|
|
2650
4320
|
};
|
|
2651
4321
|
}
|
|
2652
4322
|
static types() {
|
|
2653
4323
|
return {
|
|
2654
|
-
|
|
2655
|
-
|
|
4324
|
+
idpId: 'number',
|
|
4325
|
+
relation: 'string',
|
|
4326
|
+
userGroupType: 'string',
|
|
4327
|
+
value: 'string',
|
|
2656
4328
|
};
|
|
2657
4329
|
}
|
|
2658
4330
|
}
|
|
2659
|
-
exports.
|
|
2660
|
-
class
|
|
4331
|
+
exports.ListPrivateAccessPolicesResponseBodyPolicesCustomUserAttributes = ListPrivateAccessPolicesResponseBodyPolicesCustomUserAttributes;
|
|
4332
|
+
class ListPrivateAccessPolicesResponseBodyPolices extends $tea.Model {
|
|
2661
4333
|
constructor(map) {
|
|
2662
4334
|
super(map);
|
|
2663
4335
|
}
|
|
2664
4336
|
static names() {
|
|
2665
4337
|
return {
|
|
2666
|
-
|
|
2667
|
-
|
|
4338
|
+
applicationIds: 'ApplicationIds',
|
|
4339
|
+
applicationType: 'ApplicationType',
|
|
2668
4340
|
createTime: 'CreateTime',
|
|
4341
|
+
customUserAttributes: 'CustomUserAttributes',
|
|
4342
|
+
description: 'Description',
|
|
2669
4343
|
name: 'Name',
|
|
2670
|
-
|
|
4344
|
+
policyAction: 'PolicyAction',
|
|
4345
|
+
policyId: 'PolicyId',
|
|
4346
|
+
priority: 'Priority',
|
|
2671
4347
|
status: 'Status',
|
|
2672
|
-
|
|
2673
|
-
|
|
4348
|
+
tagIds: 'TagIds',
|
|
4349
|
+
userGroupIds: 'UserGroupIds',
|
|
4350
|
+
userGroupMode: 'UserGroupMode',
|
|
2674
4351
|
};
|
|
2675
4352
|
}
|
|
2676
4353
|
static types() {
|
|
2677
4354
|
return {
|
|
2678
|
-
|
|
2679
|
-
|
|
4355
|
+
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
4356
|
+
applicationType: 'string',
|
|
2680
4357
|
createTime: 'string',
|
|
4358
|
+
customUserAttributes: { 'type': 'array', 'itemType': ListPrivateAccessPolicesResponseBodyPolicesCustomUserAttributes },
|
|
4359
|
+
description: 'string',
|
|
2681
4360
|
name: 'string',
|
|
2682
|
-
|
|
4361
|
+
policyAction: 'string',
|
|
4362
|
+
policyId: 'string',
|
|
4363
|
+
priority: 'number',
|
|
2683
4364
|
status: 'string',
|
|
2684
|
-
|
|
2685
|
-
|
|
4365
|
+
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
4366
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
4367
|
+
userGroupMode: 'string',
|
|
2686
4368
|
};
|
|
2687
4369
|
}
|
|
2688
4370
|
}
|
|
2689
|
-
exports.
|
|
2690
|
-
class
|
|
4371
|
+
exports.ListPrivateAccessPolicesResponseBodyPolices = ListPrivateAccessPolicesResponseBodyPolices;
|
|
4372
|
+
class ListPrivateAccessTagsResponseBodyTags extends $tea.Model {
|
|
2691
4373
|
constructor(map) {
|
|
2692
4374
|
super(map);
|
|
2693
4375
|
}
|
|
2694
4376
|
static names() {
|
|
2695
4377
|
return {
|
|
2696
4378
|
applicationIds: 'ApplicationIds',
|
|
2697
|
-
applicationType: 'ApplicationType',
|
|
2698
4379
|
createTime: 'CreateTime',
|
|
2699
4380
|
description: 'Description',
|
|
2700
|
-
dynamicRouteId: 'DynamicRouteId',
|
|
2701
|
-
dynamicRouteType: 'DynamicRouteType',
|
|
2702
4381
|
name: 'Name',
|
|
2703
|
-
|
|
2704
|
-
|
|
2705
|
-
|
|
2706
|
-
status: 'Status',
|
|
2707
|
-
tagIds: 'TagIds',
|
|
4382
|
+
policyIds: 'PolicyIds',
|
|
4383
|
+
tagId: 'TagId',
|
|
4384
|
+
tagType: 'TagType',
|
|
2708
4385
|
};
|
|
2709
4386
|
}
|
|
2710
4387
|
static types() {
|
|
2711
4388
|
return {
|
|
2712
4389
|
applicationIds: { 'type': 'array', 'itemType': 'string' },
|
|
2713
|
-
applicationType: 'string',
|
|
2714
4390
|
createTime: 'string',
|
|
2715
4391
|
description: 'string',
|
|
2716
|
-
dynamicRouteId: 'string',
|
|
2717
|
-
dynamicRouteType: 'string',
|
|
2718
4392
|
name: 'string',
|
|
2719
|
-
|
|
2720
|
-
|
|
2721
|
-
|
|
2722
|
-
status: 'string',
|
|
2723
|
-
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
4393
|
+
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
4394
|
+
tagId: 'string',
|
|
4395
|
+
tagType: 'string',
|
|
2724
4396
|
};
|
|
2725
4397
|
}
|
|
2726
4398
|
}
|
|
2727
|
-
exports.
|
|
2728
|
-
class
|
|
4399
|
+
exports.ListPrivateAccessTagsResponseBodyTags = ListPrivateAccessTagsResponseBodyTags;
|
|
4400
|
+
class ListPrivateAccessTagsForDynamicRouteResponseBodyDynamicRoutesTags extends $tea.Model {
|
|
2729
4401
|
constructor(map) {
|
|
2730
4402
|
super(map);
|
|
2731
4403
|
}
|
|
2732
4404
|
static names() {
|
|
2733
4405
|
return {
|
|
2734
|
-
|
|
2735
|
-
|
|
2736
|
-
|
|
2737
|
-
|
|
4406
|
+
createTime: 'CreateTime',
|
|
4407
|
+
description: 'Description',
|
|
4408
|
+
name: 'Name',
|
|
4409
|
+
tagId: 'TagId',
|
|
4410
|
+
tagType: 'TagType',
|
|
2738
4411
|
};
|
|
2739
4412
|
}
|
|
2740
4413
|
static types() {
|
|
2741
4414
|
return {
|
|
2742
|
-
|
|
2743
|
-
|
|
2744
|
-
|
|
2745
|
-
|
|
4415
|
+
createTime: 'string',
|
|
4416
|
+
description: 'string',
|
|
4417
|
+
name: 'string',
|
|
4418
|
+
tagId: 'string',
|
|
4419
|
+
tagType: 'string',
|
|
2746
4420
|
};
|
|
2747
4421
|
}
|
|
2748
4422
|
}
|
|
2749
|
-
exports.
|
|
2750
|
-
class
|
|
4423
|
+
exports.ListPrivateAccessTagsForDynamicRouteResponseBodyDynamicRoutesTags = ListPrivateAccessTagsForDynamicRouteResponseBodyDynamicRoutesTags;
|
|
4424
|
+
class ListPrivateAccessTagsForDynamicRouteResponseBodyDynamicRoutes extends $tea.Model {
|
|
2751
4425
|
constructor(map) {
|
|
2752
4426
|
super(map);
|
|
2753
4427
|
}
|
|
2754
4428
|
static names() {
|
|
2755
4429
|
return {
|
|
2756
|
-
|
|
2757
|
-
|
|
2758
|
-
customUserAttributes: 'CustomUserAttributes',
|
|
2759
|
-
description: 'Description',
|
|
2760
|
-
name: 'Name',
|
|
2761
|
-
policyAction: 'PolicyAction',
|
|
2762
|
-
policyId: 'PolicyId',
|
|
2763
|
-
priority: 'Priority',
|
|
2764
|
-
status: 'Status',
|
|
2765
|
-
userGroupType: 'UserGroupType',
|
|
4430
|
+
dynamicRouteId: 'DynamicRouteId',
|
|
4431
|
+
tags: 'Tags',
|
|
2766
4432
|
};
|
|
2767
4433
|
}
|
|
2768
4434
|
static types() {
|
|
2769
4435
|
return {
|
|
2770
|
-
|
|
2771
|
-
|
|
2772
|
-
customUserAttributes: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPoliciesCustomUserAttributes },
|
|
2773
|
-
description: 'string',
|
|
2774
|
-
name: 'string',
|
|
2775
|
-
policyAction: 'string',
|
|
2776
|
-
policyId: 'string',
|
|
2777
|
-
priority: 'number',
|
|
2778
|
-
status: 'string',
|
|
2779
|
-
userGroupType: 'string',
|
|
4436
|
+
dynamicRouteId: 'string',
|
|
4437
|
+
tags: { 'type': 'array', 'itemType': ListPrivateAccessTagsForDynamicRouteResponseBodyDynamicRoutesTags },
|
|
2780
4438
|
};
|
|
2781
4439
|
}
|
|
2782
4440
|
}
|
|
2783
|
-
exports.
|
|
2784
|
-
class
|
|
4441
|
+
exports.ListPrivateAccessTagsForDynamicRouteResponseBodyDynamicRoutes = ListPrivateAccessTagsForDynamicRouteResponseBodyDynamicRoutes;
|
|
4442
|
+
class ListRegistrationPoliciesResponseBodyPoliciesLimitDetailLimitCount extends $tea.Model {
|
|
2785
4443
|
constructor(map) {
|
|
2786
4444
|
super(map);
|
|
2787
4445
|
}
|
|
2788
4446
|
static names() {
|
|
2789
4447
|
return {
|
|
2790
|
-
|
|
2791
|
-
|
|
4448
|
+
all: 'All',
|
|
4449
|
+
mobile: 'Mobile',
|
|
4450
|
+
PC: 'PC',
|
|
2792
4451
|
};
|
|
2793
4452
|
}
|
|
2794
4453
|
static types() {
|
|
2795
4454
|
return {
|
|
2796
|
-
|
|
2797
|
-
|
|
4455
|
+
all: 'number',
|
|
4456
|
+
mobile: 'number',
|
|
4457
|
+
PC: 'number',
|
|
2798
4458
|
};
|
|
2799
4459
|
}
|
|
2800
4460
|
}
|
|
2801
|
-
exports.
|
|
2802
|
-
class
|
|
4461
|
+
exports.ListRegistrationPoliciesResponseBodyPoliciesLimitDetailLimitCount = ListRegistrationPoliciesResponseBodyPoliciesLimitDetailLimitCount;
|
|
4462
|
+
class ListRegistrationPoliciesResponseBodyPoliciesLimitDetail extends $tea.Model {
|
|
2803
4463
|
constructor(map) {
|
|
2804
4464
|
super(map);
|
|
2805
4465
|
}
|
|
2806
4466
|
static names() {
|
|
2807
4467
|
return {
|
|
2808
|
-
|
|
2809
|
-
|
|
2810
|
-
|
|
2811
|
-
value: 'Value',
|
|
4468
|
+
deviceBelong: 'DeviceBelong',
|
|
4469
|
+
limitCount: 'LimitCount',
|
|
4470
|
+
limitType: 'LimitType',
|
|
2812
4471
|
};
|
|
2813
4472
|
}
|
|
2814
4473
|
static types() {
|
|
2815
4474
|
return {
|
|
2816
|
-
|
|
2817
|
-
|
|
2818
|
-
|
|
2819
|
-
value: 'string',
|
|
4475
|
+
deviceBelong: 'string',
|
|
4476
|
+
limitCount: ListRegistrationPoliciesResponseBodyPoliciesLimitDetailLimitCount,
|
|
4477
|
+
limitType: 'string',
|
|
2820
4478
|
};
|
|
2821
4479
|
}
|
|
2822
4480
|
}
|
|
2823
|
-
exports.
|
|
2824
|
-
class
|
|
4481
|
+
exports.ListRegistrationPoliciesResponseBodyPoliciesLimitDetail = ListRegistrationPoliciesResponseBodyPoliciesLimitDetail;
|
|
4482
|
+
class ListRegistrationPoliciesResponseBodyPolicies extends $tea.Model {
|
|
2825
4483
|
constructor(map) {
|
|
2826
4484
|
super(map);
|
|
2827
4485
|
}
|
|
2828
4486
|
static names() {
|
|
2829
4487
|
return {
|
|
2830
|
-
applicationType: 'ApplicationType',
|
|
2831
4488
|
createTime: 'CreateTime',
|
|
2832
|
-
customUserAttributes: 'CustomUserAttributes',
|
|
2833
4489
|
description: 'Description',
|
|
4490
|
+
limitDetail: 'LimitDetail',
|
|
4491
|
+
matchMode: 'MatchMode',
|
|
2834
4492
|
name: 'Name',
|
|
2835
|
-
policyAction: 'PolicyAction',
|
|
2836
4493
|
policyId: 'PolicyId',
|
|
2837
4494
|
priority: 'Priority',
|
|
2838
4495
|
status: 'Status',
|
|
2839
|
-
|
|
4496
|
+
userGroupIds: 'UserGroupIds',
|
|
4497
|
+
whitelist: 'Whitelist',
|
|
2840
4498
|
};
|
|
2841
4499
|
}
|
|
2842
4500
|
static types() {
|
|
2843
4501
|
return {
|
|
2844
|
-
applicationType: 'string',
|
|
2845
4502
|
createTime: 'string',
|
|
2846
|
-
customUserAttributes: { 'type': 'array', 'itemType': ListPolicesForPrivateAccessTagResponseBodyTagsPolicesCustomUserAttributes },
|
|
2847
4503
|
description: 'string',
|
|
4504
|
+
limitDetail: { 'type': 'array', 'itemType': ListRegistrationPoliciesResponseBodyPoliciesLimitDetail },
|
|
4505
|
+
matchMode: 'string',
|
|
2848
4506
|
name: 'string',
|
|
2849
|
-
policyAction: 'string',
|
|
2850
4507
|
policyId: 'string',
|
|
2851
4508
|
priority: 'number',
|
|
2852
4509
|
status: 'string',
|
|
2853
|
-
|
|
4510
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
4511
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
2854
4512
|
};
|
|
2855
4513
|
}
|
|
2856
4514
|
}
|
|
2857
|
-
exports.
|
|
2858
|
-
class
|
|
4515
|
+
exports.ListRegistrationPoliciesResponseBodyPolicies = ListRegistrationPoliciesResponseBodyPolicies;
|
|
4516
|
+
class ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetailLimitCount extends $tea.Model {
|
|
2859
4517
|
constructor(map) {
|
|
2860
4518
|
super(map);
|
|
2861
4519
|
}
|
|
2862
4520
|
static names() {
|
|
2863
4521
|
return {
|
|
2864
|
-
|
|
2865
|
-
|
|
4522
|
+
all: 'All',
|
|
4523
|
+
mobile: 'Mobile',
|
|
4524
|
+
PC: 'PC',
|
|
2866
4525
|
};
|
|
2867
4526
|
}
|
|
2868
4527
|
static types() {
|
|
2869
4528
|
return {
|
|
2870
|
-
|
|
2871
|
-
|
|
4529
|
+
all: 'string',
|
|
4530
|
+
mobile: 'string',
|
|
4531
|
+
PC: 'string',
|
|
2872
4532
|
};
|
|
2873
4533
|
}
|
|
2874
4534
|
}
|
|
2875
|
-
exports.
|
|
2876
|
-
class
|
|
4535
|
+
exports.ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetailLimitCount = ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetailLimitCount;
|
|
4536
|
+
class ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetail extends $tea.Model {
|
|
4537
|
+
constructor(map) {
|
|
4538
|
+
super(map);
|
|
4539
|
+
}
|
|
4540
|
+
static names() {
|
|
4541
|
+
return {
|
|
4542
|
+
deviceBelong: 'DeviceBelong',
|
|
4543
|
+
limitCount: 'LimitCount',
|
|
4544
|
+
limitType: 'LimitType',
|
|
4545
|
+
};
|
|
4546
|
+
}
|
|
4547
|
+
static types() {
|
|
4548
|
+
return {
|
|
4549
|
+
deviceBelong: 'string',
|
|
4550
|
+
limitCount: ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetailLimitCount,
|
|
4551
|
+
limitType: 'string',
|
|
4552
|
+
};
|
|
4553
|
+
}
|
|
4554
|
+
}
|
|
4555
|
+
exports.ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetail = ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetail;
|
|
4556
|
+
class ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPolicies extends $tea.Model {
|
|
2877
4557
|
constructor(map) {
|
|
2878
4558
|
super(map);
|
|
2879
4559
|
}
|
|
2880
4560
|
static names() {
|
|
2881
4561
|
return {
|
|
4562
|
+
createTime: 'CreateTime',
|
|
4563
|
+
description: 'Description',
|
|
4564
|
+
limitDetail: 'LimitDetail',
|
|
4565
|
+
matchMode: 'MatchMode',
|
|
2882
4566
|
name: 'Name',
|
|
2883
4567
|
policyId: 'PolicyId',
|
|
2884
|
-
|
|
4568
|
+
priority: 'Priority',
|
|
4569
|
+
status: 'Status',
|
|
4570
|
+
whitelist: 'Whitelist',
|
|
2885
4571
|
};
|
|
2886
4572
|
}
|
|
2887
4573
|
static types() {
|
|
2888
4574
|
return {
|
|
4575
|
+
createTime: 'string',
|
|
4576
|
+
description: 'string',
|
|
4577
|
+
limitDetail: { 'type': 'array', 'itemType': ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetail },
|
|
4578
|
+
matchMode: 'string',
|
|
2889
4579
|
name: 'string',
|
|
2890
4580
|
policyId: 'string',
|
|
2891
|
-
|
|
4581
|
+
priority: 'number',
|
|
4582
|
+
status: 'string',
|
|
4583
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
2892
4584
|
};
|
|
2893
4585
|
}
|
|
2894
4586
|
}
|
|
2895
|
-
exports.
|
|
2896
|
-
class
|
|
4587
|
+
exports.ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPolicies = ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPolicies;
|
|
4588
|
+
class ListRegistrationPoliciesForUserGroupResponseBodyUserGroups extends $tea.Model {
|
|
2897
4589
|
constructor(map) {
|
|
2898
4590
|
super(map);
|
|
2899
4591
|
}
|
|
2900
4592
|
static names() {
|
|
2901
4593
|
return {
|
|
2902
|
-
|
|
4594
|
+
policies: 'Policies',
|
|
2903
4595
|
userGroupId: 'UserGroupId',
|
|
2904
4596
|
};
|
|
2905
4597
|
}
|
|
2906
4598
|
static types() {
|
|
2907
4599
|
return {
|
|
2908
|
-
|
|
4600
|
+
policies: { 'type': 'array', 'itemType': ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPolicies },
|
|
2909
4601
|
userGroupId: 'string',
|
|
2910
4602
|
};
|
|
2911
4603
|
}
|
|
2912
4604
|
}
|
|
2913
|
-
exports.
|
|
2914
|
-
class
|
|
4605
|
+
exports.ListRegistrationPoliciesForUserGroupResponseBodyUserGroups = ListRegistrationPoliciesForUserGroupResponseBodyUserGroups;
|
|
4606
|
+
class ListSoftwareForUserDeviceResponseBodySoftware extends $tea.Model {
|
|
2915
4607
|
constructor(map) {
|
|
2916
4608
|
super(map);
|
|
2917
4609
|
}
|
|
2918
4610
|
static names() {
|
|
2919
4611
|
return {
|
|
2920
|
-
|
|
2921
|
-
|
|
4612
|
+
inc: 'Inc',
|
|
4613
|
+
installTime: 'InstallTime',
|
|
4614
|
+
name: 'Name',
|
|
4615
|
+
versions: 'Versions',
|
|
2922
4616
|
};
|
|
2923
4617
|
}
|
|
2924
4618
|
static types() {
|
|
2925
4619
|
return {
|
|
2926
|
-
|
|
2927
|
-
|
|
4620
|
+
inc: 'string',
|
|
4621
|
+
installTime: 'string',
|
|
4622
|
+
name: 'string',
|
|
4623
|
+
versions: { 'type': 'array', 'itemType': 'string' },
|
|
2928
4624
|
};
|
|
2929
4625
|
}
|
|
2930
4626
|
}
|
|
2931
|
-
exports.
|
|
2932
|
-
class
|
|
4627
|
+
exports.ListSoftwareForUserDeviceResponseBodySoftware = ListSoftwareForUserDeviceResponseBodySoftware;
|
|
4628
|
+
class ListTagsForPrivateAccessApplicationResponseBodyApplicationsTags extends $tea.Model {
|
|
2933
4629
|
constructor(map) {
|
|
2934
4630
|
super(map);
|
|
2935
4631
|
}
|
|
2936
4632
|
static names() {
|
|
2937
4633
|
return {
|
|
2938
|
-
addresses: 'Addresses',
|
|
2939
|
-
applicationId: 'ApplicationId',
|
|
2940
4634
|
createTime: 'CreateTime',
|
|
2941
4635
|
description: 'Description',
|
|
2942
4636
|
name: 'Name',
|
|
2943
|
-
|
|
2944
|
-
|
|
2945
|
-
protocol: 'Protocol',
|
|
2946
|
-
status: 'Status',
|
|
2947
|
-
tagIds: 'TagIds',
|
|
4637
|
+
tagId: 'TagId',
|
|
4638
|
+
tagType: 'TagType',
|
|
2948
4639
|
};
|
|
2949
4640
|
}
|
|
2950
4641
|
static types() {
|
|
2951
4642
|
return {
|
|
2952
|
-
addresses: { 'type': 'array', 'itemType': 'string' },
|
|
2953
|
-
applicationId: 'string',
|
|
2954
4643
|
createTime: 'string',
|
|
2955
4644
|
description: 'string',
|
|
2956
4645
|
name: 'string',
|
|
2957
|
-
|
|
2958
|
-
|
|
2959
|
-
protocol: 'string',
|
|
2960
|
-
status: 'string',
|
|
2961
|
-
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
4646
|
+
tagId: 'string',
|
|
4647
|
+
tagType: 'string',
|
|
2962
4648
|
};
|
|
2963
4649
|
}
|
|
2964
4650
|
}
|
|
2965
|
-
exports.
|
|
2966
|
-
class
|
|
4651
|
+
exports.ListTagsForPrivateAccessApplicationResponseBodyApplicationsTags = ListTagsForPrivateAccessApplicationResponseBodyApplicationsTags;
|
|
4652
|
+
class ListTagsForPrivateAccessApplicationResponseBodyApplications extends $tea.Model {
|
|
2967
4653
|
constructor(map) {
|
|
2968
4654
|
super(map);
|
|
2969
4655
|
}
|
|
2970
4656
|
static names() {
|
|
2971
4657
|
return {
|
|
2972
|
-
|
|
2973
|
-
|
|
4658
|
+
applicationId: 'ApplicationId',
|
|
4659
|
+
tags: 'Tags',
|
|
2974
4660
|
};
|
|
2975
4661
|
}
|
|
2976
4662
|
static types() {
|
|
2977
4663
|
return {
|
|
2978
|
-
|
|
2979
|
-
|
|
4664
|
+
applicationId: 'string',
|
|
4665
|
+
tags: { 'type': 'array', 'itemType': ListTagsForPrivateAccessApplicationResponseBodyApplicationsTags },
|
|
2980
4666
|
};
|
|
2981
4667
|
}
|
|
2982
4668
|
}
|
|
2983
|
-
exports.
|
|
2984
|
-
class
|
|
4669
|
+
exports.ListTagsForPrivateAccessApplicationResponseBodyApplications = ListTagsForPrivateAccessApplicationResponseBodyApplications;
|
|
4670
|
+
class ListTagsForPrivateAccessPolicyResponseBodyPolicesTags extends $tea.Model {
|
|
2985
4671
|
constructor(map) {
|
|
2986
4672
|
super(map);
|
|
2987
4673
|
}
|
|
2988
4674
|
static names() {
|
|
2989
4675
|
return {
|
|
2990
|
-
addresses: 'Addresses',
|
|
2991
|
-
applicationId: 'ApplicationId',
|
|
2992
4676
|
createTime: 'CreateTime',
|
|
2993
4677
|
description: 'Description',
|
|
2994
4678
|
name: 'Name',
|
|
2995
|
-
|
|
2996
|
-
|
|
2997
|
-
status: 'Status',
|
|
4679
|
+
tagId: 'TagId',
|
|
4680
|
+
tagType: 'TagType',
|
|
2998
4681
|
};
|
|
2999
4682
|
}
|
|
3000
4683
|
static types() {
|
|
3001
4684
|
return {
|
|
3002
|
-
addresses: { 'type': 'array', 'itemType': 'string' },
|
|
3003
|
-
applicationId: 'string',
|
|
3004
4685
|
createTime: 'string',
|
|
3005
4686
|
description: 'string',
|
|
3006
4687
|
name: 'string',
|
|
3007
|
-
|
|
3008
|
-
|
|
3009
|
-
status: 'string',
|
|
4688
|
+
tagId: 'string',
|
|
4689
|
+
tagType: 'string',
|
|
3010
4690
|
};
|
|
3011
4691
|
}
|
|
3012
4692
|
}
|
|
3013
|
-
exports.
|
|
3014
|
-
class
|
|
4693
|
+
exports.ListTagsForPrivateAccessPolicyResponseBodyPolicesTags = ListTagsForPrivateAccessPolicyResponseBodyPolicesTags;
|
|
4694
|
+
class ListTagsForPrivateAccessPolicyResponseBodyPolices extends $tea.Model {
|
|
3015
4695
|
constructor(map) {
|
|
3016
4696
|
super(map);
|
|
3017
4697
|
}
|
|
3018
4698
|
static names() {
|
|
3019
4699
|
return {
|
|
3020
|
-
|
|
3021
|
-
|
|
4700
|
+
policyId: 'PolicyId',
|
|
4701
|
+
tags: 'Tags',
|
|
3022
4702
|
};
|
|
3023
4703
|
}
|
|
3024
4704
|
static types() {
|
|
3025
4705
|
return {
|
|
3026
|
-
|
|
3027
|
-
|
|
4706
|
+
policyId: 'string',
|
|
4707
|
+
tags: { 'type': 'array', 'itemType': ListTagsForPrivateAccessPolicyResponseBodyPolicesTags },
|
|
3028
4708
|
};
|
|
3029
4709
|
}
|
|
3030
4710
|
}
|
|
3031
|
-
exports.
|
|
3032
|
-
class
|
|
4711
|
+
exports.ListTagsForPrivateAccessPolicyResponseBodyPolices = ListTagsForPrivateAccessPolicyResponseBodyPolices;
|
|
4712
|
+
class ListUserDevicesResponseBodyDevices extends $tea.Model {
|
|
4713
|
+
constructor(map) {
|
|
4714
|
+
super(map);
|
|
4715
|
+
}
|
|
4716
|
+
static names() {
|
|
4717
|
+
return {
|
|
4718
|
+
appStatus: 'AppStatus',
|
|
4719
|
+
appVersion: 'AppVersion',
|
|
4720
|
+
CPU: 'CPU',
|
|
4721
|
+
createTime: 'CreateTime',
|
|
4722
|
+
department: 'Department',
|
|
4723
|
+
deviceBelong: 'DeviceBelong',
|
|
4724
|
+
deviceModel: 'DeviceModel',
|
|
4725
|
+
deviceStatus: 'DeviceStatus',
|
|
4726
|
+
deviceTag: 'DeviceTag',
|
|
4727
|
+
deviceType: 'DeviceType',
|
|
4728
|
+
deviceVersion: 'DeviceVersion',
|
|
4729
|
+
disk: 'Disk',
|
|
4730
|
+
dlpStatus: 'DlpStatus',
|
|
4731
|
+
hostname: 'Hostname',
|
|
4732
|
+
iaStatus: 'IaStatus',
|
|
4733
|
+
innerIP: 'InnerIP',
|
|
4734
|
+
mac: 'Mac',
|
|
4735
|
+
memory: 'Memory',
|
|
4736
|
+
nacStatus: 'NacStatus',
|
|
4737
|
+
paStatus: 'PaStatus',
|
|
4738
|
+
saseUserId: 'SaseUserId',
|
|
4739
|
+
sharingStatus: 'SharingStatus',
|
|
4740
|
+
srcIP: 'SrcIP',
|
|
4741
|
+
updateTime: 'UpdateTime',
|
|
4742
|
+
username: 'Username',
|
|
4743
|
+
};
|
|
4744
|
+
}
|
|
4745
|
+
static types() {
|
|
4746
|
+
return {
|
|
4747
|
+
appStatus: 'string',
|
|
4748
|
+
appVersion: 'string',
|
|
4749
|
+
CPU: 'string',
|
|
4750
|
+
createTime: 'string',
|
|
4751
|
+
department: 'string',
|
|
4752
|
+
deviceBelong: 'string',
|
|
4753
|
+
deviceModel: 'string',
|
|
4754
|
+
deviceStatus: 'string',
|
|
4755
|
+
deviceTag: 'string',
|
|
4756
|
+
deviceType: 'string',
|
|
4757
|
+
deviceVersion: 'string',
|
|
4758
|
+
disk: 'string',
|
|
4759
|
+
dlpStatus: 'string',
|
|
4760
|
+
hostname: 'string',
|
|
4761
|
+
iaStatus: 'string',
|
|
4762
|
+
innerIP: 'string',
|
|
4763
|
+
mac: 'string',
|
|
4764
|
+
memory: 'string',
|
|
4765
|
+
nacStatus: 'string',
|
|
4766
|
+
paStatus: 'string',
|
|
4767
|
+
saseUserId: 'string',
|
|
4768
|
+
sharingStatus: 'boolean',
|
|
4769
|
+
srcIP: 'string',
|
|
4770
|
+
updateTime: 'string',
|
|
4771
|
+
username: 'string',
|
|
4772
|
+
};
|
|
4773
|
+
}
|
|
4774
|
+
}
|
|
4775
|
+
exports.ListUserDevicesResponseBodyDevices = ListUserDevicesResponseBodyDevices;
|
|
4776
|
+
class ListUserGroupsResponseBodyUserGroupsAttributes extends $tea.Model {
|
|
3033
4777
|
constructor(map) {
|
|
3034
4778
|
super(map);
|
|
3035
4779
|
}
|
|
@@ -3050,202 +4794,216 @@ class ListPrivateAccessPolicesResponseBodyPolicesCustomUserAttributes extends $t
|
|
|
3050
4794
|
};
|
|
3051
4795
|
}
|
|
3052
4796
|
}
|
|
3053
|
-
exports.
|
|
3054
|
-
class
|
|
4797
|
+
exports.ListUserGroupsResponseBodyUserGroupsAttributes = ListUserGroupsResponseBodyUserGroupsAttributes;
|
|
4798
|
+
class ListUserGroupsResponseBodyUserGroups extends $tea.Model {
|
|
3055
4799
|
constructor(map) {
|
|
3056
4800
|
super(map);
|
|
3057
4801
|
}
|
|
3058
4802
|
static names() {
|
|
3059
4803
|
return {
|
|
3060
|
-
|
|
3061
|
-
applicationType: 'ApplicationType',
|
|
4804
|
+
attributes: 'Attributes',
|
|
3062
4805
|
createTime: 'CreateTime',
|
|
3063
|
-
customUserAttributes: 'CustomUserAttributes',
|
|
3064
4806
|
description: 'Description',
|
|
3065
4807
|
name: 'Name',
|
|
3066
|
-
|
|
3067
|
-
policyId: 'PolicyId',
|
|
3068
|
-
priority: 'Priority',
|
|
3069
|
-
status: 'Status',
|
|
3070
|
-
tagIds: 'TagIds',
|
|
3071
|
-
userGroupIds: 'UserGroupIds',
|
|
3072
|
-
userGroupMode: 'UserGroupMode',
|
|
4808
|
+
userGroupId: 'UserGroupId',
|
|
3073
4809
|
};
|
|
3074
4810
|
}
|
|
3075
4811
|
static types() {
|
|
3076
4812
|
return {
|
|
3077
|
-
|
|
3078
|
-
applicationType: 'string',
|
|
4813
|
+
attributes: { 'type': 'array', 'itemType': ListUserGroupsResponseBodyUserGroupsAttributes },
|
|
3079
4814
|
createTime: 'string',
|
|
3080
|
-
customUserAttributes: { 'type': 'array', 'itemType': ListPrivateAccessPolicesResponseBodyPolicesCustomUserAttributes },
|
|
3081
4815
|
description: 'string',
|
|
3082
4816
|
name: 'string',
|
|
3083
|
-
|
|
3084
|
-
policyId: 'string',
|
|
3085
|
-
priority: 'number',
|
|
3086
|
-
status: 'string',
|
|
3087
|
-
tagIds: { 'type': 'array', 'itemType': 'string' },
|
|
3088
|
-
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
3089
|
-
userGroupMode: 'string',
|
|
4817
|
+
userGroupId: 'string',
|
|
3090
4818
|
};
|
|
3091
4819
|
}
|
|
3092
4820
|
}
|
|
3093
|
-
exports.
|
|
3094
|
-
class
|
|
4821
|
+
exports.ListUserGroupsResponseBodyUserGroups = ListUserGroupsResponseBodyUserGroups;
|
|
4822
|
+
class ListUserGroupsForPrivateAccessPolicyResponseBodyPolicesUserGroupsAttributes extends $tea.Model {
|
|
3095
4823
|
constructor(map) {
|
|
3096
4824
|
super(map);
|
|
3097
4825
|
}
|
|
3098
4826
|
static names() {
|
|
3099
4827
|
return {
|
|
3100
|
-
|
|
3101
|
-
|
|
3102
|
-
|
|
3103
|
-
|
|
3104
|
-
policyIds: 'PolicyIds',
|
|
3105
|
-
tagId: 'TagId',
|
|
3106
|
-
tagType: 'TagType',
|
|
4828
|
+
idpId: 'IdpId',
|
|
4829
|
+
relation: 'Relation',
|
|
4830
|
+
userGroupType: 'UserGroupType',
|
|
4831
|
+
value: 'Value',
|
|
3107
4832
|
};
|
|
3108
4833
|
}
|
|
3109
4834
|
static types() {
|
|
3110
4835
|
return {
|
|
3111
|
-
|
|
3112
|
-
|
|
3113
|
-
|
|
3114
|
-
|
|
3115
|
-
policyIds: { 'type': 'array', 'itemType': 'string' },
|
|
3116
|
-
tagId: 'string',
|
|
3117
|
-
tagType: 'string',
|
|
4836
|
+
idpId: 'number',
|
|
4837
|
+
relation: 'string',
|
|
4838
|
+
userGroupType: 'string',
|
|
4839
|
+
value: 'string',
|
|
3118
4840
|
};
|
|
3119
4841
|
}
|
|
3120
4842
|
}
|
|
3121
|
-
exports.
|
|
3122
|
-
class
|
|
4843
|
+
exports.ListUserGroupsForPrivateAccessPolicyResponseBodyPolicesUserGroupsAttributes = ListUserGroupsForPrivateAccessPolicyResponseBodyPolicesUserGroupsAttributes;
|
|
4844
|
+
class ListUserGroupsForPrivateAccessPolicyResponseBodyPolicesUserGroups extends $tea.Model {
|
|
3123
4845
|
constructor(map) {
|
|
3124
4846
|
super(map);
|
|
3125
4847
|
}
|
|
3126
4848
|
static names() {
|
|
3127
4849
|
return {
|
|
4850
|
+
attributes: 'Attributes',
|
|
3128
4851
|
createTime: 'CreateTime',
|
|
3129
4852
|
description: 'Description',
|
|
3130
4853
|
name: 'Name',
|
|
3131
|
-
|
|
3132
|
-
tagType: 'TagType',
|
|
4854
|
+
userGroupId: 'UserGroupId',
|
|
3133
4855
|
};
|
|
3134
4856
|
}
|
|
3135
4857
|
static types() {
|
|
3136
4858
|
return {
|
|
4859
|
+
attributes: { 'type': 'array', 'itemType': ListUserGroupsForPrivateAccessPolicyResponseBodyPolicesUserGroupsAttributes },
|
|
3137
4860
|
createTime: 'string',
|
|
3138
4861
|
description: 'string',
|
|
3139
4862
|
name: 'string',
|
|
3140
|
-
|
|
3141
|
-
|
|
4863
|
+
userGroupId: 'string',
|
|
4864
|
+
};
|
|
4865
|
+
}
|
|
4866
|
+
}
|
|
4867
|
+
exports.ListUserGroupsForPrivateAccessPolicyResponseBodyPolicesUserGroups = ListUserGroupsForPrivateAccessPolicyResponseBodyPolicesUserGroups;
|
|
4868
|
+
class ListUserGroupsForPrivateAccessPolicyResponseBodyPolices extends $tea.Model {
|
|
4869
|
+
constructor(map) {
|
|
4870
|
+
super(map);
|
|
4871
|
+
}
|
|
4872
|
+
static names() {
|
|
4873
|
+
return {
|
|
4874
|
+
policyId: 'PolicyId',
|
|
4875
|
+
userGroups: 'UserGroups',
|
|
4876
|
+
};
|
|
4877
|
+
}
|
|
4878
|
+
static types() {
|
|
4879
|
+
return {
|
|
4880
|
+
policyId: 'string',
|
|
4881
|
+
userGroups: { 'type': 'array', 'itemType': ListUserGroupsForPrivateAccessPolicyResponseBodyPolicesUserGroups },
|
|
3142
4882
|
};
|
|
3143
4883
|
}
|
|
3144
4884
|
}
|
|
3145
|
-
exports.
|
|
3146
|
-
class
|
|
4885
|
+
exports.ListUserGroupsForPrivateAccessPolicyResponseBodyPolices = ListUserGroupsForPrivateAccessPolicyResponseBodyPolices;
|
|
4886
|
+
class ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroupsAttributes extends $tea.Model {
|
|
3147
4887
|
constructor(map) {
|
|
3148
4888
|
super(map);
|
|
3149
4889
|
}
|
|
3150
4890
|
static names() {
|
|
3151
4891
|
return {
|
|
3152
|
-
|
|
3153
|
-
|
|
4892
|
+
idpId: 'IdpId',
|
|
4893
|
+
relation: 'Relation',
|
|
4894
|
+
userGroupType: 'UserGroupType',
|
|
4895
|
+
value: 'Value',
|
|
3154
4896
|
};
|
|
3155
4897
|
}
|
|
3156
4898
|
static types() {
|
|
3157
4899
|
return {
|
|
3158
|
-
|
|
3159
|
-
|
|
4900
|
+
idpId: 'number',
|
|
4901
|
+
relation: 'string',
|
|
4902
|
+
userGroupType: 'string',
|
|
4903
|
+
value: 'string',
|
|
3160
4904
|
};
|
|
3161
4905
|
}
|
|
3162
4906
|
}
|
|
3163
|
-
exports.
|
|
3164
|
-
class
|
|
4907
|
+
exports.ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroupsAttributes = ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroupsAttributes;
|
|
4908
|
+
class ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroups extends $tea.Model {
|
|
3165
4909
|
constructor(map) {
|
|
3166
4910
|
super(map);
|
|
3167
4911
|
}
|
|
3168
4912
|
static names() {
|
|
3169
4913
|
return {
|
|
4914
|
+
attributes: 'Attributes',
|
|
3170
4915
|
createTime: 'CreateTime',
|
|
3171
4916
|
description: 'Description',
|
|
3172
4917
|
name: 'Name',
|
|
3173
|
-
|
|
3174
|
-
tagType: 'TagType',
|
|
4918
|
+
userGroupId: 'UserGroupId',
|
|
3175
4919
|
};
|
|
3176
4920
|
}
|
|
3177
4921
|
static types() {
|
|
3178
4922
|
return {
|
|
4923
|
+
attributes: { 'type': 'array', 'itemType': ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroupsAttributes },
|
|
3179
4924
|
createTime: 'string',
|
|
3180
4925
|
description: 'string',
|
|
3181
4926
|
name: 'string',
|
|
3182
|
-
|
|
3183
|
-
tagType: 'string',
|
|
4927
|
+
userGroupId: 'string',
|
|
3184
4928
|
};
|
|
3185
4929
|
}
|
|
3186
4930
|
}
|
|
3187
|
-
exports.
|
|
3188
|
-
class
|
|
4931
|
+
exports.ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroups = ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroups;
|
|
4932
|
+
class ListUserGroupsForRegistrationPolicyResponseBodyPolicies extends $tea.Model {
|
|
3189
4933
|
constructor(map) {
|
|
3190
4934
|
super(map);
|
|
3191
4935
|
}
|
|
3192
4936
|
static names() {
|
|
3193
4937
|
return {
|
|
3194
|
-
|
|
3195
|
-
|
|
4938
|
+
policyId: 'PolicyId',
|
|
4939
|
+
userGroups: 'UserGroups',
|
|
3196
4940
|
};
|
|
3197
4941
|
}
|
|
3198
4942
|
static types() {
|
|
3199
4943
|
return {
|
|
3200
|
-
|
|
3201
|
-
|
|
4944
|
+
policyId: 'string',
|
|
4945
|
+
userGroups: { 'type': 'array', 'itemType': ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroups },
|
|
3202
4946
|
};
|
|
3203
4947
|
}
|
|
3204
4948
|
}
|
|
3205
|
-
exports.
|
|
3206
|
-
class
|
|
4949
|
+
exports.ListUserGroupsForRegistrationPolicyResponseBodyPolicies = ListUserGroupsForRegistrationPolicyResponseBodyPolicies;
|
|
4950
|
+
class UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBodyApplications extends $tea.Model {
|
|
3207
4951
|
constructor(map) {
|
|
3208
4952
|
super(map);
|
|
3209
4953
|
}
|
|
3210
4954
|
static names() {
|
|
3211
4955
|
return {
|
|
4956
|
+
applicationId: 'ApplicationId',
|
|
3212
4957
|
createTime: 'CreateTime',
|
|
4958
|
+
department: 'Department',
|
|
3213
4959
|
description: 'Description',
|
|
3214
|
-
|
|
3215
|
-
|
|
3216
|
-
|
|
4960
|
+
deviceTag: 'DeviceTag',
|
|
4961
|
+
deviceType: 'DeviceType',
|
|
4962
|
+
hostname: 'Hostname',
|
|
4963
|
+
isUsed: 'IsUsed',
|
|
4964
|
+
mac: 'Mac',
|
|
4965
|
+
saseUserId: 'SaseUserId',
|
|
4966
|
+
status: 'Status',
|
|
4967
|
+
username: 'Username',
|
|
3217
4968
|
};
|
|
3218
4969
|
}
|
|
3219
4970
|
static types() {
|
|
3220
4971
|
return {
|
|
4972
|
+
applicationId: 'string',
|
|
3221
4973
|
createTime: 'string',
|
|
4974
|
+
department: 'string',
|
|
3222
4975
|
description: 'string',
|
|
3223
|
-
|
|
3224
|
-
|
|
3225
|
-
|
|
4976
|
+
deviceTag: 'string',
|
|
4977
|
+
deviceType: 'string',
|
|
4978
|
+
hostname: 'string',
|
|
4979
|
+
isUsed: 'boolean',
|
|
4980
|
+
mac: 'string',
|
|
4981
|
+
saseUserId: 'string',
|
|
4982
|
+
status: 'string',
|
|
4983
|
+
username: 'string',
|
|
3226
4984
|
};
|
|
3227
4985
|
}
|
|
3228
4986
|
}
|
|
3229
|
-
exports.
|
|
3230
|
-
class
|
|
4987
|
+
exports.UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBodyApplications = UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBodyApplications;
|
|
4988
|
+
class UpdatePrivateAccessApplicationRequestPortRanges extends $tea.Model {
|
|
3231
4989
|
constructor(map) {
|
|
3232
4990
|
super(map);
|
|
3233
4991
|
}
|
|
3234
4992
|
static names() {
|
|
3235
4993
|
return {
|
|
3236
|
-
|
|
3237
|
-
|
|
4994
|
+
begin: 'Begin',
|
|
4995
|
+
end: 'End',
|
|
3238
4996
|
};
|
|
3239
4997
|
}
|
|
3240
4998
|
static types() {
|
|
3241
4999
|
return {
|
|
3242
|
-
|
|
3243
|
-
|
|
5000
|
+
begin: 'number',
|
|
5001
|
+
end: 'number',
|
|
3244
5002
|
};
|
|
3245
5003
|
}
|
|
3246
5004
|
}
|
|
3247
|
-
exports.
|
|
3248
|
-
class
|
|
5005
|
+
exports.UpdatePrivateAccessApplicationRequestPortRanges = UpdatePrivateAccessApplicationRequestPortRanges;
|
|
5006
|
+
class UpdatePrivateAccessPolicyRequestCustomUserAttributes extends $tea.Model {
|
|
3249
5007
|
constructor(map) {
|
|
3250
5008
|
super(map);
|
|
3251
5009
|
}
|
|
@@ -3266,135 +5024,249 @@ class ListUserGroupsResponseBodyUserGroupsAttributes extends $tea.Model {
|
|
|
3266
5024
|
};
|
|
3267
5025
|
}
|
|
3268
5026
|
}
|
|
3269
|
-
exports.
|
|
3270
|
-
class
|
|
5027
|
+
exports.UpdatePrivateAccessPolicyRequestCustomUserAttributes = UpdatePrivateAccessPolicyRequestCustomUserAttributes;
|
|
5028
|
+
class UpdateRegistrationPolicyRequestCompanyLimitCount extends $tea.Model {
|
|
3271
5029
|
constructor(map) {
|
|
3272
5030
|
super(map);
|
|
3273
5031
|
}
|
|
3274
5032
|
static names() {
|
|
3275
5033
|
return {
|
|
3276
|
-
|
|
3277
|
-
|
|
3278
|
-
|
|
3279
|
-
name: 'Name',
|
|
3280
|
-
userGroupId: 'UserGroupId',
|
|
5034
|
+
all: 'All',
|
|
5035
|
+
mobile: 'Mobile',
|
|
5036
|
+
PC: 'PC',
|
|
3281
5037
|
};
|
|
3282
5038
|
}
|
|
3283
5039
|
static types() {
|
|
3284
5040
|
return {
|
|
3285
|
-
|
|
3286
|
-
|
|
3287
|
-
|
|
3288
|
-
name: 'string',
|
|
3289
|
-
userGroupId: 'string',
|
|
5041
|
+
all: 'number',
|
|
5042
|
+
mobile: 'number',
|
|
5043
|
+
PC: 'number',
|
|
3290
5044
|
};
|
|
3291
5045
|
}
|
|
3292
5046
|
}
|
|
3293
|
-
exports.
|
|
3294
|
-
class
|
|
5047
|
+
exports.UpdateRegistrationPolicyRequestCompanyLimitCount = UpdateRegistrationPolicyRequestCompanyLimitCount;
|
|
5048
|
+
class UpdateRegistrationPolicyRequestPersonalLimitCount extends $tea.Model {
|
|
3295
5049
|
constructor(map) {
|
|
3296
5050
|
super(map);
|
|
3297
5051
|
}
|
|
3298
5052
|
static names() {
|
|
3299
5053
|
return {
|
|
3300
|
-
|
|
3301
|
-
|
|
3302
|
-
|
|
3303
|
-
value: 'Value',
|
|
5054
|
+
all: 'All',
|
|
5055
|
+
mobile: 'Mobile',
|
|
5056
|
+
PC: 'PC',
|
|
3304
5057
|
};
|
|
3305
5058
|
}
|
|
3306
5059
|
static types() {
|
|
3307
5060
|
return {
|
|
3308
|
-
|
|
3309
|
-
|
|
3310
|
-
|
|
3311
|
-
value: 'string',
|
|
5061
|
+
all: 'number',
|
|
5062
|
+
mobile: 'number',
|
|
5063
|
+
PC: 'number',
|
|
3312
5064
|
};
|
|
3313
5065
|
}
|
|
3314
5066
|
}
|
|
3315
|
-
exports.
|
|
3316
|
-
class
|
|
5067
|
+
exports.UpdateRegistrationPolicyRequestPersonalLimitCount = UpdateRegistrationPolicyRequestPersonalLimitCount;
|
|
5068
|
+
class UpdateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount extends $tea.Model {
|
|
3317
5069
|
constructor(map) {
|
|
3318
5070
|
super(map);
|
|
3319
5071
|
}
|
|
3320
5072
|
static names() {
|
|
3321
5073
|
return {
|
|
3322
|
-
|
|
3323
|
-
|
|
3324
|
-
|
|
3325
|
-
name: 'Name',
|
|
3326
|
-
userGroupId: 'UserGroupId',
|
|
5074
|
+
all: 'All',
|
|
5075
|
+
mobile: 'Mobile',
|
|
5076
|
+
PC: 'PC',
|
|
3327
5077
|
};
|
|
3328
5078
|
}
|
|
3329
5079
|
static types() {
|
|
3330
5080
|
return {
|
|
3331
|
-
|
|
3332
|
-
|
|
3333
|
-
|
|
3334
|
-
name: 'string',
|
|
3335
|
-
userGroupId: 'string',
|
|
5081
|
+
all: 'number',
|
|
5082
|
+
mobile: 'number',
|
|
5083
|
+
PC: 'number',
|
|
3336
5084
|
};
|
|
3337
5085
|
}
|
|
3338
5086
|
}
|
|
3339
|
-
exports.
|
|
3340
|
-
class
|
|
5087
|
+
exports.UpdateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount = UpdateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount;
|
|
5088
|
+
class UpdateRegistrationPolicyResponseBodyPolicyLimitDetail extends $tea.Model {
|
|
3341
5089
|
constructor(map) {
|
|
3342
5090
|
super(map);
|
|
3343
5091
|
}
|
|
3344
5092
|
static names() {
|
|
3345
5093
|
return {
|
|
3346
|
-
|
|
3347
|
-
|
|
5094
|
+
deviceBelong: 'DeviceBelong',
|
|
5095
|
+
limitCount: 'LimitCount',
|
|
5096
|
+
limitType: 'LimitType',
|
|
3348
5097
|
};
|
|
3349
5098
|
}
|
|
3350
5099
|
static types() {
|
|
3351
5100
|
return {
|
|
3352
|
-
|
|
3353
|
-
|
|
5101
|
+
deviceBelong: 'string',
|
|
5102
|
+
limitCount: UpdateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount,
|
|
5103
|
+
limitType: 'string',
|
|
3354
5104
|
};
|
|
3355
5105
|
}
|
|
3356
5106
|
}
|
|
3357
|
-
exports.
|
|
3358
|
-
class
|
|
5107
|
+
exports.UpdateRegistrationPolicyResponseBodyPolicyLimitDetail = UpdateRegistrationPolicyResponseBodyPolicyLimitDetail;
|
|
5108
|
+
class UpdateRegistrationPolicyResponseBodyPolicy extends $tea.Model {
|
|
3359
5109
|
constructor(map) {
|
|
3360
5110
|
super(map);
|
|
3361
5111
|
}
|
|
3362
5112
|
static names() {
|
|
3363
5113
|
return {
|
|
3364
|
-
|
|
3365
|
-
|
|
5114
|
+
createTime: 'CreateTime',
|
|
5115
|
+
description: 'Description',
|
|
5116
|
+
limitDetail: 'LimitDetail',
|
|
5117
|
+
matchMode: 'MatchMode',
|
|
5118
|
+
name: 'Name',
|
|
5119
|
+
policyId: 'PolicyId',
|
|
5120
|
+
priority: 'Priority',
|
|
5121
|
+
status: 'Status',
|
|
5122
|
+
userGroupIds: 'UserGroupIds',
|
|
5123
|
+
whitelist: 'Whitelist',
|
|
3366
5124
|
};
|
|
3367
5125
|
}
|
|
3368
5126
|
static types() {
|
|
3369
5127
|
return {
|
|
3370
|
-
|
|
3371
|
-
|
|
5128
|
+
createTime: 'string',
|
|
5129
|
+
description: 'string',
|
|
5130
|
+
limitDetail: { 'type': 'array', 'itemType': UpdateRegistrationPolicyResponseBodyPolicyLimitDetail },
|
|
5131
|
+
matchMode: 'string',
|
|
5132
|
+
name: 'string',
|
|
5133
|
+
policyId: 'string',
|
|
5134
|
+
priority: 'string',
|
|
5135
|
+
status: 'string',
|
|
5136
|
+
userGroupIds: { 'type': 'array', 'itemType': 'string' },
|
|
5137
|
+
whitelist: { 'type': 'array', 'itemType': 'string' },
|
|
3372
5138
|
};
|
|
3373
5139
|
}
|
|
3374
5140
|
}
|
|
3375
|
-
exports.
|
|
3376
|
-
class
|
|
5141
|
+
exports.UpdateRegistrationPolicyResponseBodyPolicy = UpdateRegistrationPolicyResponseBodyPolicy;
|
|
5142
|
+
class UpdateUserDevicesSharingStatusResponseBodyDevices extends $tea.Model {
|
|
3377
5143
|
constructor(map) {
|
|
3378
5144
|
super(map);
|
|
3379
5145
|
}
|
|
3380
5146
|
static names() {
|
|
3381
5147
|
return {
|
|
3382
|
-
|
|
3383
|
-
|
|
3384
|
-
|
|
3385
|
-
|
|
3386
|
-
|
|
3387
|
-
|
|
3388
|
-
|
|
3389
|
-
|
|
3390
|
-
|
|
3391
|
-
|
|
3392
|
-
|
|
3393
|
-
|
|
5148
|
+
appStatus: 'AppStatus',
|
|
5149
|
+
appVersion: 'AppVersion',
|
|
5150
|
+
CPU: 'CPU',
|
|
5151
|
+
createTime: 'CreateTime',
|
|
5152
|
+
department: 'Department',
|
|
5153
|
+
deviceBelong: 'DeviceBelong',
|
|
5154
|
+
deviceModel: 'DeviceModel',
|
|
5155
|
+
deviceStatus: 'DeviceStatus',
|
|
5156
|
+
deviceTag: 'DeviceTag',
|
|
5157
|
+
deviceType: 'DeviceType',
|
|
5158
|
+
deviceVersion: 'DeviceVersion',
|
|
5159
|
+
disk: 'Disk',
|
|
5160
|
+
dlpStatus: 'DlpStatus',
|
|
5161
|
+
hostname: 'Hostname',
|
|
5162
|
+
iaStatus: 'IaStatus',
|
|
5163
|
+
innerIP: 'InnerIP',
|
|
5164
|
+
mac: 'Mac',
|
|
5165
|
+
memory: 'Memory',
|
|
5166
|
+
nacStatus: 'NacStatus',
|
|
5167
|
+
paStatus: 'PaStatus',
|
|
5168
|
+
saseUserId: 'SaseUserId',
|
|
5169
|
+
sharingStatus: 'SharingStatus',
|
|
5170
|
+
srcIP: 'SrcIP',
|
|
5171
|
+
updateTime: 'UpdateTime',
|
|
5172
|
+
username: 'Username',
|
|
5173
|
+
};
|
|
5174
|
+
}
|
|
5175
|
+
static types() {
|
|
5176
|
+
return {
|
|
5177
|
+
appStatus: 'string',
|
|
5178
|
+
appVersion: 'string',
|
|
5179
|
+
CPU: 'string',
|
|
5180
|
+
createTime: 'string',
|
|
5181
|
+
department: 'string',
|
|
5182
|
+
deviceBelong: 'string',
|
|
5183
|
+
deviceModel: 'string',
|
|
5184
|
+
deviceStatus: 'string',
|
|
5185
|
+
deviceTag: 'string',
|
|
5186
|
+
deviceType: 'string',
|
|
5187
|
+
deviceVersion: 'string',
|
|
5188
|
+
disk: 'string',
|
|
5189
|
+
dlpStatus: 'string',
|
|
5190
|
+
hostname: 'string',
|
|
5191
|
+
iaStatus: 'string',
|
|
5192
|
+
innerIP: 'string',
|
|
5193
|
+
mac: 'string',
|
|
5194
|
+
memory: 'string',
|
|
5195
|
+
nacStatus: 'string',
|
|
5196
|
+
paStatus: 'string',
|
|
5197
|
+
saseUserId: 'string',
|
|
5198
|
+
sharingStatus: 'boolean',
|
|
5199
|
+
srcIP: 'string',
|
|
5200
|
+
updateTime: 'string',
|
|
5201
|
+
username: 'string',
|
|
3394
5202
|
};
|
|
3395
5203
|
}
|
|
3396
5204
|
}
|
|
3397
|
-
exports.
|
|
5205
|
+
exports.UpdateUserDevicesSharingStatusResponseBodyDevices = UpdateUserDevicesSharingStatusResponseBodyDevices;
|
|
5206
|
+
class UpdateUserDevicesStatusResponseBodyDevices extends $tea.Model {
|
|
5207
|
+
constructor(map) {
|
|
5208
|
+
super(map);
|
|
5209
|
+
}
|
|
5210
|
+
static names() {
|
|
5211
|
+
return {
|
|
5212
|
+
appStatus: 'AppStatus',
|
|
5213
|
+
appVersion: 'AppVersion',
|
|
5214
|
+
CPU: 'CPU',
|
|
5215
|
+
createTime: 'CreateTime',
|
|
5216
|
+
department: 'Department',
|
|
5217
|
+
deviceBelong: 'DeviceBelong',
|
|
5218
|
+
deviceModel: 'DeviceModel',
|
|
5219
|
+
deviceStatus: 'DeviceStatus',
|
|
5220
|
+
deviceTag: 'DeviceTag',
|
|
5221
|
+
deviceType: 'DeviceType',
|
|
5222
|
+
deviceVersion: 'DeviceVersion',
|
|
5223
|
+
disk: 'Disk',
|
|
5224
|
+
dlpStatus: 'DlpStatus',
|
|
5225
|
+
hostname: 'Hostname',
|
|
5226
|
+
iaStatus: 'IaStatus',
|
|
5227
|
+
innerIP: 'InnerIP',
|
|
5228
|
+
mac: 'Mac',
|
|
5229
|
+
memory: 'Memory',
|
|
5230
|
+
nacStatus: 'NacStatus',
|
|
5231
|
+
paStatus: 'PaStatus',
|
|
5232
|
+
saseUserId: 'SaseUserId',
|
|
5233
|
+
sharingStatus: 'SharingStatus',
|
|
5234
|
+
srcIP: 'SrcIP',
|
|
5235
|
+
updateTime: 'UpdateTime',
|
|
5236
|
+
username: 'Username',
|
|
5237
|
+
};
|
|
5238
|
+
}
|
|
5239
|
+
static types() {
|
|
5240
|
+
return {
|
|
5241
|
+
appStatus: 'string',
|
|
5242
|
+
appVersion: 'string',
|
|
5243
|
+
CPU: 'string',
|
|
5244
|
+
createTime: 'string',
|
|
5245
|
+
department: 'string',
|
|
5246
|
+
deviceBelong: 'string',
|
|
5247
|
+
deviceModel: 'string',
|
|
5248
|
+
deviceStatus: 'string',
|
|
5249
|
+
deviceTag: 'string',
|
|
5250
|
+
deviceType: 'string',
|
|
5251
|
+
deviceVersion: 'string',
|
|
5252
|
+
disk: 'string',
|
|
5253
|
+
dlpStatus: 'string',
|
|
5254
|
+
hostname: 'string',
|
|
5255
|
+
iaStatus: 'string',
|
|
5256
|
+
innerIP: 'string',
|
|
5257
|
+
mac: 'string',
|
|
5258
|
+
memory: 'string',
|
|
5259
|
+
nacStatus: 'string',
|
|
5260
|
+
paStatus: 'string',
|
|
5261
|
+
saseUserId: 'string',
|
|
5262
|
+
sharingStatus: 'boolean',
|
|
5263
|
+
srcIP: 'string',
|
|
5264
|
+
updateTime: 'string',
|
|
5265
|
+
username: 'string',
|
|
5266
|
+
};
|
|
5267
|
+
}
|
|
5268
|
+
}
|
|
5269
|
+
exports.UpdateUserDevicesStatusResponseBodyDevices = UpdateUserDevicesStatusResponseBodyDevices;
|
|
3398
5270
|
class UpdateUserGroupRequestAttributes extends $tea.Model {
|
|
3399
5271
|
constructor(map) {
|
|
3400
5272
|
super(map);
|
|
@@ -3655,6 +5527,72 @@ class Client extends openapi_client_1.default {
|
|
|
3655
5527
|
let runtime = new $Util.RuntimeOptions({});
|
|
3656
5528
|
return await this.createPrivateAccessTagWithOptions(request, runtime);
|
|
3657
5529
|
}
|
|
5530
|
+
async createRegistrationPolicyWithOptions(tmpReq, runtime) {
|
|
5531
|
+
tea_util_1.default.validateModel(tmpReq);
|
|
5532
|
+
let request = new CreateRegistrationPolicyShrinkRequest({});
|
|
5533
|
+
openapi_util_1.default.convert(tmpReq, request);
|
|
5534
|
+
if (!tea_util_1.default.isUnset(tmpReq.companyLimitCount)) {
|
|
5535
|
+
request.companyLimitCountShrink = openapi_util_1.default.arrayToStringWithSpecifiedStyle(tmpReq.companyLimitCount, "CompanyLimitCount", "json");
|
|
5536
|
+
}
|
|
5537
|
+
if (!tea_util_1.default.isUnset(tmpReq.personalLimitCount)) {
|
|
5538
|
+
request.personalLimitCountShrink = openapi_util_1.default.arrayToStringWithSpecifiedStyle(tmpReq.personalLimitCount, "PersonalLimitCount", "json");
|
|
5539
|
+
}
|
|
5540
|
+
let body = {};
|
|
5541
|
+
if (!tea_util_1.default.isUnset(request.companyLimitCountShrink)) {
|
|
5542
|
+
body["CompanyLimitCount"] = request.companyLimitCountShrink;
|
|
5543
|
+
}
|
|
5544
|
+
if (!tea_util_1.default.isUnset(request.companyLimitType)) {
|
|
5545
|
+
body["CompanyLimitType"] = request.companyLimitType;
|
|
5546
|
+
}
|
|
5547
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
5548
|
+
body["Description"] = request.description;
|
|
5549
|
+
}
|
|
5550
|
+
if (!tea_util_1.default.isUnset(request.matchMode)) {
|
|
5551
|
+
body["MatchMode"] = request.matchMode;
|
|
5552
|
+
}
|
|
5553
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
5554
|
+
body["Name"] = request.name;
|
|
5555
|
+
}
|
|
5556
|
+
if (!tea_util_1.default.isUnset(request.personalLimitCountShrink)) {
|
|
5557
|
+
body["PersonalLimitCount"] = request.personalLimitCountShrink;
|
|
5558
|
+
}
|
|
5559
|
+
if (!tea_util_1.default.isUnset(request.personalLimitType)) {
|
|
5560
|
+
body["PersonalLimitType"] = request.personalLimitType;
|
|
5561
|
+
}
|
|
5562
|
+
if (!tea_util_1.default.isUnset(request.priority)) {
|
|
5563
|
+
body["Priority"] = request.priority;
|
|
5564
|
+
}
|
|
5565
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
5566
|
+
body["Status"] = request.status;
|
|
5567
|
+
}
|
|
5568
|
+
let bodyFlat = {};
|
|
5569
|
+
if (!tea_util_1.default.isUnset(request.userGroupIds)) {
|
|
5570
|
+
bodyFlat["UserGroupIds"] = request.userGroupIds;
|
|
5571
|
+
}
|
|
5572
|
+
if (!tea_util_1.default.isUnset(request.whitelist)) {
|
|
5573
|
+
bodyFlat["Whitelist"] = request.whitelist;
|
|
5574
|
+
}
|
|
5575
|
+
body = Object.assign(Object.assign({}, body), openapi_util_1.default.query(bodyFlat));
|
|
5576
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
5577
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
5578
|
+
});
|
|
5579
|
+
let params = new $OpenApi.Params({
|
|
5580
|
+
action: "CreateRegistrationPolicy",
|
|
5581
|
+
version: "2023-01-20",
|
|
5582
|
+
protocol: "HTTPS",
|
|
5583
|
+
pathname: "/",
|
|
5584
|
+
method: "POST",
|
|
5585
|
+
authType: "AK",
|
|
5586
|
+
style: "RPC",
|
|
5587
|
+
reqBodyType: "formData",
|
|
5588
|
+
bodyType: "json",
|
|
5589
|
+
});
|
|
5590
|
+
return $tea.cast(await this.callApi(params, req, runtime), new CreateRegistrationPolicyResponse({}));
|
|
5591
|
+
}
|
|
5592
|
+
async createRegistrationPolicy(request) {
|
|
5593
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
5594
|
+
return await this.createRegistrationPolicyWithOptions(request, runtime);
|
|
5595
|
+
}
|
|
3658
5596
|
async createUserGroupWithOptions(request, runtime) {
|
|
3659
5597
|
tea_util_1.default.validateModel(request);
|
|
3660
5598
|
let body = {};
|
|
@@ -3793,6 +5731,34 @@ class Client extends openapi_client_1.default {
|
|
|
3793
5731
|
let runtime = new $Util.RuntimeOptions({});
|
|
3794
5732
|
return await this.deletePrivateAccessTagWithOptions(request, runtime);
|
|
3795
5733
|
}
|
|
5734
|
+
async deleteRegistrationPoliciesWithOptions(request, runtime) {
|
|
5735
|
+
tea_util_1.default.validateModel(request);
|
|
5736
|
+
let body = {};
|
|
5737
|
+
let bodyFlat = {};
|
|
5738
|
+
if (!tea_util_1.default.isUnset(request.policyIds)) {
|
|
5739
|
+
bodyFlat["PolicyIds"] = request.policyIds;
|
|
5740
|
+
}
|
|
5741
|
+
body = Object.assign(Object.assign({}, body), openapi_util_1.default.query(bodyFlat));
|
|
5742
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
5743
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
5744
|
+
});
|
|
5745
|
+
let params = new $OpenApi.Params({
|
|
5746
|
+
action: "DeleteRegistrationPolicies",
|
|
5747
|
+
version: "2023-01-20",
|
|
5748
|
+
protocol: "HTTPS",
|
|
5749
|
+
pathname: "/",
|
|
5750
|
+
method: "POST",
|
|
5751
|
+
authType: "AK",
|
|
5752
|
+
style: "RPC",
|
|
5753
|
+
reqBodyType: "formData",
|
|
5754
|
+
bodyType: "json",
|
|
5755
|
+
});
|
|
5756
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DeleteRegistrationPoliciesResponse({}));
|
|
5757
|
+
}
|
|
5758
|
+
async deleteRegistrationPolicies(request) {
|
|
5759
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
5760
|
+
return await this.deleteRegistrationPoliciesWithOptions(request, runtime);
|
|
5761
|
+
}
|
|
3796
5762
|
async deleteUserGroupWithOptions(request, runtime) {
|
|
3797
5763
|
tea_util_1.default.validateModel(request);
|
|
3798
5764
|
let body = {};
|
|
@@ -3837,30 +5803,76 @@ class Client extends openapi_client_1.default {
|
|
|
3837
5803
|
body: openapi_util_1.default.parseToMap(body),
|
|
3838
5804
|
});
|
|
3839
5805
|
let params = new $OpenApi.Params({
|
|
3840
|
-
action: "DetachApplication2Connector",
|
|
5806
|
+
action: "DetachApplication2Connector",
|
|
5807
|
+
version: "2023-01-20",
|
|
5808
|
+
protocol: "HTTPS",
|
|
5809
|
+
pathname: "/",
|
|
5810
|
+
method: "POST",
|
|
5811
|
+
authType: "AK",
|
|
5812
|
+
style: "RPC",
|
|
5813
|
+
reqBodyType: "formData",
|
|
5814
|
+
bodyType: "json",
|
|
5815
|
+
});
|
|
5816
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DetachApplication2ConnectorResponse({}));
|
|
5817
|
+
}
|
|
5818
|
+
async detachApplication2Connector(request) {
|
|
5819
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
5820
|
+
return await this.detachApplication2ConnectorWithOptions(request, runtime);
|
|
5821
|
+
}
|
|
5822
|
+
async getDynamicRouteWithOptions(request, runtime) {
|
|
5823
|
+
tea_util_1.default.validateModel(request);
|
|
5824
|
+
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
5825
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
5826
|
+
query: openapi_util_1.default.query(query),
|
|
5827
|
+
});
|
|
5828
|
+
let params = new $OpenApi.Params({
|
|
5829
|
+
action: "GetDynamicRoute",
|
|
5830
|
+
version: "2023-01-20",
|
|
5831
|
+
protocol: "HTTPS",
|
|
5832
|
+
pathname: "/",
|
|
5833
|
+
method: "GET",
|
|
5834
|
+
authType: "AK",
|
|
5835
|
+
style: "RPC",
|
|
5836
|
+
reqBodyType: "formData",
|
|
5837
|
+
bodyType: "json",
|
|
5838
|
+
});
|
|
5839
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetDynamicRouteResponse({}));
|
|
5840
|
+
}
|
|
5841
|
+
async getDynamicRoute(request) {
|
|
5842
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
5843
|
+
return await this.getDynamicRouteWithOptions(request, runtime);
|
|
5844
|
+
}
|
|
5845
|
+
async getPrivateAccessApplicationWithOptions(request, runtime) {
|
|
5846
|
+
tea_util_1.default.validateModel(request);
|
|
5847
|
+
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
5848
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
5849
|
+
query: openapi_util_1.default.query(query),
|
|
5850
|
+
});
|
|
5851
|
+
let params = new $OpenApi.Params({
|
|
5852
|
+
action: "GetPrivateAccessApplication",
|
|
3841
5853
|
version: "2023-01-20",
|
|
3842
5854
|
protocol: "HTTPS",
|
|
3843
5855
|
pathname: "/",
|
|
3844
|
-
method: "
|
|
5856
|
+
method: "GET",
|
|
3845
5857
|
authType: "AK",
|
|
3846
5858
|
style: "RPC",
|
|
3847
5859
|
reqBodyType: "formData",
|
|
3848
5860
|
bodyType: "json",
|
|
3849
5861
|
});
|
|
3850
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
5862
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetPrivateAccessApplicationResponse({}));
|
|
3851
5863
|
}
|
|
3852
|
-
async
|
|
5864
|
+
async getPrivateAccessApplication(request) {
|
|
3853
5865
|
let runtime = new $Util.RuntimeOptions({});
|
|
3854
|
-
return await this.
|
|
5866
|
+
return await this.getPrivateAccessApplicationWithOptions(request, runtime);
|
|
3855
5867
|
}
|
|
3856
|
-
async
|
|
5868
|
+
async getPrivateAccessPolicyWithOptions(request, runtime) {
|
|
3857
5869
|
tea_util_1.default.validateModel(request);
|
|
3858
5870
|
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
3859
5871
|
let req = new $OpenApi.OpenApiRequest({
|
|
3860
5872
|
query: openapi_util_1.default.query(query),
|
|
3861
5873
|
});
|
|
3862
5874
|
let params = new $OpenApi.Params({
|
|
3863
|
-
action: "
|
|
5875
|
+
action: "GetPrivateAccessPolicy",
|
|
3864
5876
|
version: "2023-01-20",
|
|
3865
5877
|
protocol: "HTTPS",
|
|
3866
5878
|
pathname: "/",
|
|
@@ -3870,20 +5882,20 @@ class Client extends openapi_client_1.default {
|
|
|
3870
5882
|
reqBodyType: "formData",
|
|
3871
5883
|
bodyType: "json",
|
|
3872
5884
|
});
|
|
3873
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
5885
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetPrivateAccessPolicyResponse({}));
|
|
3874
5886
|
}
|
|
3875
|
-
async
|
|
5887
|
+
async getPrivateAccessPolicy(request) {
|
|
3876
5888
|
let runtime = new $Util.RuntimeOptions({});
|
|
3877
|
-
return await this.
|
|
5889
|
+
return await this.getPrivateAccessPolicyWithOptions(request, runtime);
|
|
3878
5890
|
}
|
|
3879
|
-
async
|
|
5891
|
+
async getRegistrationPolicyWithOptions(request, runtime) {
|
|
3880
5892
|
tea_util_1.default.validateModel(request);
|
|
3881
5893
|
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
3882
5894
|
let req = new $OpenApi.OpenApiRequest({
|
|
3883
5895
|
query: openapi_util_1.default.query(query),
|
|
3884
5896
|
});
|
|
3885
5897
|
let params = new $OpenApi.Params({
|
|
3886
|
-
action: "
|
|
5898
|
+
action: "GetRegistrationPolicy",
|
|
3887
5899
|
version: "2023-01-20",
|
|
3888
5900
|
protocol: "HTTPS",
|
|
3889
5901
|
pathname: "/",
|
|
@@ -3893,20 +5905,20 @@ class Client extends openapi_client_1.default {
|
|
|
3893
5905
|
reqBodyType: "formData",
|
|
3894
5906
|
bodyType: "json",
|
|
3895
5907
|
});
|
|
3896
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
5908
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetRegistrationPolicyResponse({}));
|
|
3897
5909
|
}
|
|
3898
|
-
async
|
|
5910
|
+
async getRegistrationPolicy(request) {
|
|
3899
5911
|
let runtime = new $Util.RuntimeOptions({});
|
|
3900
|
-
return await this.
|
|
5912
|
+
return await this.getRegistrationPolicyWithOptions(request, runtime);
|
|
3901
5913
|
}
|
|
3902
|
-
async
|
|
5914
|
+
async getUserDeviceWithOptions(request, runtime) {
|
|
3903
5915
|
tea_util_1.default.validateModel(request);
|
|
3904
5916
|
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
3905
5917
|
let req = new $OpenApi.OpenApiRequest({
|
|
3906
5918
|
query: openapi_util_1.default.query(query),
|
|
3907
5919
|
});
|
|
3908
5920
|
let params = new $OpenApi.Params({
|
|
3909
|
-
action: "
|
|
5921
|
+
action: "GetUserDevice",
|
|
3910
5922
|
version: "2023-01-20",
|
|
3911
5923
|
protocol: "HTTPS",
|
|
3912
5924
|
pathname: "/",
|
|
@@ -3916,11 +5928,11 @@ class Client extends openapi_client_1.default {
|
|
|
3916
5928
|
reqBodyType: "formData",
|
|
3917
5929
|
bodyType: "json",
|
|
3918
5930
|
});
|
|
3919
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
5931
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetUserDeviceResponse({}));
|
|
3920
5932
|
}
|
|
3921
|
-
async
|
|
5933
|
+
async getUserDevice(request) {
|
|
3922
5934
|
let runtime = new $Util.RuntimeOptions({});
|
|
3923
|
-
return await this.
|
|
5935
|
+
return await this.getUserDeviceWithOptions(request, runtime);
|
|
3924
5936
|
}
|
|
3925
5937
|
async getUserGroupWithOptions(request, runtime) {
|
|
3926
5938
|
tea_util_1.default.validateModel(request);
|
|
@@ -4056,6 +6068,29 @@ class Client extends openapi_client_1.default {
|
|
|
4056
6068
|
let runtime = new $Util.RuntimeOptions({});
|
|
4057
6069
|
return await this.listDynamicRoutesWithOptions(request, runtime);
|
|
4058
6070
|
}
|
|
6071
|
+
async listExcessiveDeviceRegistrationApplicationsWithOptions(request, runtime) {
|
|
6072
|
+
tea_util_1.default.validateModel(request);
|
|
6073
|
+
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
6074
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6075
|
+
query: openapi_util_1.default.query(query),
|
|
6076
|
+
});
|
|
6077
|
+
let params = new $OpenApi.Params({
|
|
6078
|
+
action: "ListExcessiveDeviceRegistrationApplications",
|
|
6079
|
+
version: "2023-01-20",
|
|
6080
|
+
protocol: "HTTPS",
|
|
6081
|
+
pathname: "/",
|
|
6082
|
+
method: "GET",
|
|
6083
|
+
authType: "AK",
|
|
6084
|
+
style: "RPC",
|
|
6085
|
+
reqBodyType: "formData",
|
|
6086
|
+
bodyType: "json",
|
|
6087
|
+
});
|
|
6088
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListExcessiveDeviceRegistrationApplicationsResponse({}));
|
|
6089
|
+
}
|
|
6090
|
+
async listExcessiveDeviceRegistrationApplications(request) {
|
|
6091
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6092
|
+
return await this.listExcessiveDeviceRegistrationApplicationsWithOptions(request, runtime);
|
|
6093
|
+
}
|
|
4059
6094
|
async listPolicesForPrivateAccessApplicationWithOptions(request, runtime) {
|
|
4060
6095
|
tea_util_1.default.validateModel(request);
|
|
4061
6096
|
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
@@ -4240,6 +6275,75 @@ class Client extends openapi_client_1.default {
|
|
|
4240
6275
|
let runtime = new $Util.RuntimeOptions({});
|
|
4241
6276
|
return await this.listPrivateAccessTagsForDynamicRouteWithOptions(request, runtime);
|
|
4242
6277
|
}
|
|
6278
|
+
async listRegistrationPoliciesWithOptions(request, runtime) {
|
|
6279
|
+
tea_util_1.default.validateModel(request);
|
|
6280
|
+
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
6281
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6282
|
+
query: openapi_util_1.default.query(query),
|
|
6283
|
+
});
|
|
6284
|
+
let params = new $OpenApi.Params({
|
|
6285
|
+
action: "ListRegistrationPolicies",
|
|
6286
|
+
version: "2023-01-20",
|
|
6287
|
+
protocol: "HTTPS",
|
|
6288
|
+
pathname: "/",
|
|
6289
|
+
method: "GET",
|
|
6290
|
+
authType: "AK",
|
|
6291
|
+
style: "RPC",
|
|
6292
|
+
reqBodyType: "formData",
|
|
6293
|
+
bodyType: "json",
|
|
6294
|
+
});
|
|
6295
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListRegistrationPoliciesResponse({}));
|
|
6296
|
+
}
|
|
6297
|
+
async listRegistrationPolicies(request) {
|
|
6298
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6299
|
+
return await this.listRegistrationPoliciesWithOptions(request, runtime);
|
|
6300
|
+
}
|
|
6301
|
+
async listRegistrationPoliciesForUserGroupWithOptions(request, runtime) {
|
|
6302
|
+
tea_util_1.default.validateModel(request);
|
|
6303
|
+
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
6304
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6305
|
+
query: openapi_util_1.default.query(query),
|
|
6306
|
+
});
|
|
6307
|
+
let params = new $OpenApi.Params({
|
|
6308
|
+
action: "ListRegistrationPoliciesForUserGroup",
|
|
6309
|
+
version: "2023-01-20",
|
|
6310
|
+
protocol: "HTTPS",
|
|
6311
|
+
pathname: "/",
|
|
6312
|
+
method: "GET",
|
|
6313
|
+
authType: "AK",
|
|
6314
|
+
style: "RPC",
|
|
6315
|
+
reqBodyType: "formData",
|
|
6316
|
+
bodyType: "json",
|
|
6317
|
+
});
|
|
6318
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListRegistrationPoliciesForUserGroupResponse({}));
|
|
6319
|
+
}
|
|
6320
|
+
async listRegistrationPoliciesForUserGroup(request) {
|
|
6321
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6322
|
+
return await this.listRegistrationPoliciesForUserGroupWithOptions(request, runtime);
|
|
6323
|
+
}
|
|
6324
|
+
async listSoftwareForUserDeviceWithOptions(request, runtime) {
|
|
6325
|
+
tea_util_1.default.validateModel(request);
|
|
6326
|
+
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
6327
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6328
|
+
query: openapi_util_1.default.query(query),
|
|
6329
|
+
});
|
|
6330
|
+
let params = new $OpenApi.Params({
|
|
6331
|
+
action: "ListSoftwareForUserDevice",
|
|
6332
|
+
version: "2023-01-20",
|
|
6333
|
+
protocol: "HTTPS",
|
|
6334
|
+
pathname: "/",
|
|
6335
|
+
method: "GET",
|
|
6336
|
+
authType: "AK",
|
|
6337
|
+
style: "RPC",
|
|
6338
|
+
reqBodyType: "formData",
|
|
6339
|
+
bodyType: "json",
|
|
6340
|
+
});
|
|
6341
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListSoftwareForUserDeviceResponse({}));
|
|
6342
|
+
}
|
|
6343
|
+
async listSoftwareForUserDevice(request) {
|
|
6344
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6345
|
+
return await this.listSoftwareForUserDeviceWithOptions(request, runtime);
|
|
6346
|
+
}
|
|
4243
6347
|
async listTagsForPrivateAccessApplicationWithOptions(request, runtime) {
|
|
4244
6348
|
tea_util_1.default.validateModel(request);
|
|
4245
6349
|
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
@@ -4286,6 +6390,29 @@ class Client extends openapi_client_1.default {
|
|
|
4286
6390
|
let runtime = new $Util.RuntimeOptions({});
|
|
4287
6391
|
return await this.listTagsForPrivateAccessPolicyWithOptions(request, runtime);
|
|
4288
6392
|
}
|
|
6393
|
+
async listUserDevicesWithOptions(request, runtime) {
|
|
6394
|
+
tea_util_1.default.validateModel(request);
|
|
6395
|
+
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
6396
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6397
|
+
query: openapi_util_1.default.query(query),
|
|
6398
|
+
});
|
|
6399
|
+
let params = new $OpenApi.Params({
|
|
6400
|
+
action: "ListUserDevices",
|
|
6401
|
+
version: "2023-01-20",
|
|
6402
|
+
protocol: "HTTPS",
|
|
6403
|
+
pathname: "/",
|
|
6404
|
+
method: "GET",
|
|
6405
|
+
authType: "AK",
|
|
6406
|
+
style: "RPC",
|
|
6407
|
+
reqBodyType: "formData",
|
|
6408
|
+
bodyType: "json",
|
|
6409
|
+
});
|
|
6410
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListUserDevicesResponse({}));
|
|
6411
|
+
}
|
|
6412
|
+
async listUserDevices(request) {
|
|
6413
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6414
|
+
return await this.listUserDevicesWithOptions(request, runtime);
|
|
6415
|
+
}
|
|
4289
6416
|
async listUserGroupsWithOptions(request, runtime) {
|
|
4290
6417
|
tea_util_1.default.validateModel(request);
|
|
4291
6418
|
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
@@ -4332,6 +6459,29 @@ class Client extends openapi_client_1.default {
|
|
|
4332
6459
|
let runtime = new $Util.RuntimeOptions({});
|
|
4333
6460
|
return await this.listUserGroupsForPrivateAccessPolicyWithOptions(request, runtime);
|
|
4334
6461
|
}
|
|
6462
|
+
async listUserGroupsForRegistrationPolicyWithOptions(request, runtime) {
|
|
6463
|
+
tea_util_1.default.validateModel(request);
|
|
6464
|
+
let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
|
|
6465
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6466
|
+
query: openapi_util_1.default.query(query),
|
|
6467
|
+
});
|
|
6468
|
+
let params = new $OpenApi.Params({
|
|
6469
|
+
action: "ListUserGroupsForRegistrationPolicy",
|
|
6470
|
+
version: "2023-01-20",
|
|
6471
|
+
protocol: "HTTPS",
|
|
6472
|
+
pathname: "/",
|
|
6473
|
+
method: "GET",
|
|
6474
|
+
authType: "AK",
|
|
6475
|
+
style: "RPC",
|
|
6476
|
+
reqBodyType: "formData",
|
|
6477
|
+
bodyType: "json",
|
|
6478
|
+
});
|
|
6479
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListUserGroupsForRegistrationPolicyResponse({}));
|
|
6480
|
+
}
|
|
6481
|
+
async listUserGroupsForRegistrationPolicy(request) {
|
|
6482
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6483
|
+
return await this.listUserGroupsForRegistrationPolicyWithOptions(request, runtime);
|
|
6484
|
+
}
|
|
4335
6485
|
async updateDynamicRouteWithOptions(request, runtime) {
|
|
4336
6486
|
tea_util_1.default.validateModel(request);
|
|
4337
6487
|
let body = {};
|
|
@@ -4393,6 +6543,37 @@ class Client extends openapi_client_1.default {
|
|
|
4393
6543
|
let runtime = new $Util.RuntimeOptions({});
|
|
4394
6544
|
return await this.updateDynamicRouteWithOptions(request, runtime);
|
|
4395
6545
|
}
|
|
6546
|
+
async updateExcessiveDeviceRegistrationApplicationsStatusWithOptions(request, runtime) {
|
|
6547
|
+
tea_util_1.default.validateModel(request);
|
|
6548
|
+
let body = {};
|
|
6549
|
+
let bodyFlat = {};
|
|
6550
|
+
if (!tea_util_1.default.isUnset(request.applicationIds)) {
|
|
6551
|
+
bodyFlat["ApplicationIds"] = request.applicationIds;
|
|
6552
|
+
}
|
|
6553
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
6554
|
+
body["Status"] = request.status;
|
|
6555
|
+
}
|
|
6556
|
+
body = Object.assign(Object.assign({}, body), openapi_util_1.default.query(bodyFlat));
|
|
6557
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6558
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
6559
|
+
});
|
|
6560
|
+
let params = new $OpenApi.Params({
|
|
6561
|
+
action: "UpdateExcessiveDeviceRegistrationApplicationsStatus",
|
|
6562
|
+
version: "2023-01-20",
|
|
6563
|
+
protocol: "HTTPS",
|
|
6564
|
+
pathname: "/",
|
|
6565
|
+
method: "POST",
|
|
6566
|
+
authType: "AK",
|
|
6567
|
+
style: "RPC",
|
|
6568
|
+
reqBodyType: "formData",
|
|
6569
|
+
bodyType: "json",
|
|
6570
|
+
});
|
|
6571
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateExcessiveDeviceRegistrationApplicationsStatusResponse({}));
|
|
6572
|
+
}
|
|
6573
|
+
async updateExcessiveDeviceRegistrationApplicationsStatus(request) {
|
|
6574
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6575
|
+
return await this.updateExcessiveDeviceRegistrationApplicationsStatusWithOptions(request, runtime);
|
|
6576
|
+
}
|
|
4396
6577
|
async updatePrivateAccessApplicationWithOptions(request, runtime) {
|
|
4397
6578
|
tea_util_1.default.validateModel(request);
|
|
4398
6579
|
let body = {};
|
|
@@ -4503,6 +6684,137 @@ class Client extends openapi_client_1.default {
|
|
|
4503
6684
|
let runtime = new $Util.RuntimeOptions({});
|
|
4504
6685
|
return await this.updatePrivateAccessPolicyWithOptions(request, runtime);
|
|
4505
6686
|
}
|
|
6687
|
+
async updateRegistrationPolicyWithOptions(tmpReq, runtime) {
|
|
6688
|
+
tea_util_1.default.validateModel(tmpReq);
|
|
6689
|
+
let request = new UpdateRegistrationPolicyShrinkRequest({});
|
|
6690
|
+
openapi_util_1.default.convert(tmpReq, request);
|
|
6691
|
+
if (!tea_util_1.default.isUnset(tmpReq.companyLimitCount)) {
|
|
6692
|
+
request.companyLimitCountShrink = openapi_util_1.default.arrayToStringWithSpecifiedStyle(tmpReq.companyLimitCount, "CompanyLimitCount", "json");
|
|
6693
|
+
}
|
|
6694
|
+
if (!tea_util_1.default.isUnset(tmpReq.personalLimitCount)) {
|
|
6695
|
+
request.personalLimitCountShrink = openapi_util_1.default.arrayToStringWithSpecifiedStyle(tmpReq.personalLimitCount, "PersonalLimitCount", "json");
|
|
6696
|
+
}
|
|
6697
|
+
let body = {};
|
|
6698
|
+
if (!tea_util_1.default.isUnset(request.companyLimitCountShrink)) {
|
|
6699
|
+
body["CompanyLimitCount"] = request.companyLimitCountShrink;
|
|
6700
|
+
}
|
|
6701
|
+
if (!tea_util_1.default.isUnset(request.companyLimitType)) {
|
|
6702
|
+
body["CompanyLimitType"] = request.companyLimitType;
|
|
6703
|
+
}
|
|
6704
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
6705
|
+
body["Description"] = request.description;
|
|
6706
|
+
}
|
|
6707
|
+
if (!tea_util_1.default.isUnset(request.matchMode)) {
|
|
6708
|
+
body["MatchMode"] = request.matchMode;
|
|
6709
|
+
}
|
|
6710
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
6711
|
+
body["Name"] = request.name;
|
|
6712
|
+
}
|
|
6713
|
+
if (!tea_util_1.default.isUnset(request.personalLimitCountShrink)) {
|
|
6714
|
+
body["PersonalLimitCount"] = request.personalLimitCountShrink;
|
|
6715
|
+
}
|
|
6716
|
+
if (!tea_util_1.default.isUnset(request.personalLimitType)) {
|
|
6717
|
+
body["PersonalLimitType"] = request.personalLimitType;
|
|
6718
|
+
}
|
|
6719
|
+
if (!tea_util_1.default.isUnset(request.policyId)) {
|
|
6720
|
+
body["PolicyId"] = request.policyId;
|
|
6721
|
+
}
|
|
6722
|
+
if (!tea_util_1.default.isUnset(request.priority)) {
|
|
6723
|
+
body["Priority"] = request.priority;
|
|
6724
|
+
}
|
|
6725
|
+
if (!tea_util_1.default.isUnset(request.status)) {
|
|
6726
|
+
body["Status"] = request.status;
|
|
6727
|
+
}
|
|
6728
|
+
let bodyFlat = {};
|
|
6729
|
+
if (!tea_util_1.default.isUnset(request.userGroupIds)) {
|
|
6730
|
+
bodyFlat["UserGroupIds"] = request.userGroupIds;
|
|
6731
|
+
}
|
|
6732
|
+
if (!tea_util_1.default.isUnset(request.whitelist)) {
|
|
6733
|
+
bodyFlat["Whitelist"] = request.whitelist;
|
|
6734
|
+
}
|
|
6735
|
+
body = Object.assign(Object.assign({}, body), openapi_util_1.default.query(bodyFlat));
|
|
6736
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6737
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
6738
|
+
});
|
|
6739
|
+
let params = new $OpenApi.Params({
|
|
6740
|
+
action: "UpdateRegistrationPolicy",
|
|
6741
|
+
version: "2023-01-20",
|
|
6742
|
+
protocol: "HTTPS",
|
|
6743
|
+
pathname: "/",
|
|
6744
|
+
method: "POST",
|
|
6745
|
+
authType: "AK",
|
|
6746
|
+
style: "RPC",
|
|
6747
|
+
reqBodyType: "formData",
|
|
6748
|
+
bodyType: "json",
|
|
6749
|
+
});
|
|
6750
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateRegistrationPolicyResponse({}));
|
|
6751
|
+
}
|
|
6752
|
+
async updateRegistrationPolicy(request) {
|
|
6753
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6754
|
+
return await this.updateRegistrationPolicyWithOptions(request, runtime);
|
|
6755
|
+
}
|
|
6756
|
+
async updateUserDevicesSharingStatusWithOptions(request, runtime) {
|
|
6757
|
+
tea_util_1.default.validateModel(request);
|
|
6758
|
+
let body = {};
|
|
6759
|
+
let bodyFlat = {};
|
|
6760
|
+
if (!tea_util_1.default.isUnset(request.deviceTags)) {
|
|
6761
|
+
bodyFlat["DeviceTags"] = request.deviceTags;
|
|
6762
|
+
}
|
|
6763
|
+
if (!tea_util_1.default.isUnset(request.sharingStatus)) {
|
|
6764
|
+
body["SharingStatus"] = request.sharingStatus;
|
|
6765
|
+
}
|
|
6766
|
+
body = Object.assign(Object.assign({}, body), openapi_util_1.default.query(bodyFlat));
|
|
6767
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6768
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
6769
|
+
});
|
|
6770
|
+
let params = new $OpenApi.Params({
|
|
6771
|
+
action: "UpdateUserDevicesSharingStatus",
|
|
6772
|
+
version: "2023-01-20",
|
|
6773
|
+
protocol: "HTTPS",
|
|
6774
|
+
pathname: "/",
|
|
6775
|
+
method: "POST",
|
|
6776
|
+
authType: "AK",
|
|
6777
|
+
style: "RPC",
|
|
6778
|
+
reqBodyType: "formData",
|
|
6779
|
+
bodyType: "json",
|
|
6780
|
+
});
|
|
6781
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateUserDevicesSharingStatusResponse({}));
|
|
6782
|
+
}
|
|
6783
|
+
async updateUserDevicesSharingStatus(request) {
|
|
6784
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6785
|
+
return await this.updateUserDevicesSharingStatusWithOptions(request, runtime);
|
|
6786
|
+
}
|
|
6787
|
+
async updateUserDevicesStatusWithOptions(request, runtime) {
|
|
6788
|
+
tea_util_1.default.validateModel(request);
|
|
6789
|
+
let body = {};
|
|
6790
|
+
if (!tea_util_1.default.isUnset(request.deviceAction)) {
|
|
6791
|
+
body["DeviceAction"] = request.deviceAction;
|
|
6792
|
+
}
|
|
6793
|
+
let bodyFlat = {};
|
|
6794
|
+
if (!tea_util_1.default.isUnset(request.deviceTags)) {
|
|
6795
|
+
bodyFlat["DeviceTags"] = request.deviceTags;
|
|
6796
|
+
}
|
|
6797
|
+
body = Object.assign(Object.assign({}, body), openapi_util_1.default.query(bodyFlat));
|
|
6798
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
6799
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
6800
|
+
});
|
|
6801
|
+
let params = new $OpenApi.Params({
|
|
6802
|
+
action: "UpdateUserDevicesStatus",
|
|
6803
|
+
version: "2023-01-20",
|
|
6804
|
+
protocol: "HTTPS",
|
|
6805
|
+
pathname: "/",
|
|
6806
|
+
method: "POST",
|
|
6807
|
+
authType: "AK",
|
|
6808
|
+
style: "RPC",
|
|
6809
|
+
reqBodyType: "formData",
|
|
6810
|
+
bodyType: "json",
|
|
6811
|
+
});
|
|
6812
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateUserDevicesStatusResponse({}));
|
|
6813
|
+
}
|
|
6814
|
+
async updateUserDevicesStatus(request) {
|
|
6815
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
6816
|
+
return await this.updateUserDevicesStatusWithOptions(request, runtime);
|
|
6817
|
+
}
|
|
4506
6818
|
async updateUserGroupWithOptions(request, runtime) {
|
|
4507
6819
|
tea_util_1.default.validateModel(request);
|
|
4508
6820
|
let body = {};
|