@alicloud/csas20230120 1.1.2 → 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 +1307 -34
- package/dist/client.js +2961 -679
- package/dist/client.js.map +1 -1
- package/package.json +1 -1
- package/src/client.ts +3267 -354
package/dist/client.d.ts
CHANGED
|
@@ -248,6 +248,79 @@ export declare class CreatePrivateAccessTagResponse extends $tea.Model {
|
|
|
248
248
|
[key: string]: any;
|
|
249
249
|
});
|
|
250
250
|
}
|
|
251
|
+
export declare class CreateRegistrationPolicyRequest extends $tea.Model {
|
|
252
|
+
companyLimitCount?: CreateRegistrationPolicyRequestCompanyLimitCount;
|
|
253
|
+
companyLimitType?: string;
|
|
254
|
+
description?: string;
|
|
255
|
+
matchMode?: string;
|
|
256
|
+
name?: string;
|
|
257
|
+
personalLimitCount?: CreateRegistrationPolicyRequestPersonalLimitCount;
|
|
258
|
+
personalLimitType?: string;
|
|
259
|
+
priority?: number;
|
|
260
|
+
status?: string;
|
|
261
|
+
userGroupIds?: string[];
|
|
262
|
+
whitelist?: string[];
|
|
263
|
+
static names(): {
|
|
264
|
+
[key: string]: string;
|
|
265
|
+
};
|
|
266
|
+
static types(): {
|
|
267
|
+
[key: string]: any;
|
|
268
|
+
};
|
|
269
|
+
constructor(map?: {
|
|
270
|
+
[key: string]: any;
|
|
271
|
+
});
|
|
272
|
+
}
|
|
273
|
+
export declare class CreateRegistrationPolicyShrinkRequest extends $tea.Model {
|
|
274
|
+
companyLimitCountShrink?: string;
|
|
275
|
+
companyLimitType?: string;
|
|
276
|
+
description?: string;
|
|
277
|
+
matchMode?: string;
|
|
278
|
+
name?: string;
|
|
279
|
+
personalLimitCountShrink?: string;
|
|
280
|
+
personalLimitType?: string;
|
|
281
|
+
priority?: number;
|
|
282
|
+
status?: string;
|
|
283
|
+
userGroupIds?: string[];
|
|
284
|
+
whitelist?: string[];
|
|
285
|
+
static names(): {
|
|
286
|
+
[key: string]: string;
|
|
287
|
+
};
|
|
288
|
+
static types(): {
|
|
289
|
+
[key: string]: any;
|
|
290
|
+
};
|
|
291
|
+
constructor(map?: {
|
|
292
|
+
[key: string]: any;
|
|
293
|
+
});
|
|
294
|
+
}
|
|
295
|
+
export declare class CreateRegistrationPolicyResponseBody extends $tea.Model {
|
|
296
|
+
policy?: CreateRegistrationPolicyResponseBodyPolicy;
|
|
297
|
+
requestId?: string;
|
|
298
|
+
static names(): {
|
|
299
|
+
[key: string]: string;
|
|
300
|
+
};
|
|
301
|
+
static types(): {
|
|
302
|
+
[key: string]: any;
|
|
303
|
+
};
|
|
304
|
+
constructor(map?: {
|
|
305
|
+
[key: string]: any;
|
|
306
|
+
});
|
|
307
|
+
}
|
|
308
|
+
export declare class CreateRegistrationPolicyResponse extends $tea.Model {
|
|
309
|
+
headers: {
|
|
310
|
+
[key: string]: string;
|
|
311
|
+
};
|
|
312
|
+
statusCode: number;
|
|
313
|
+
body: CreateRegistrationPolicyResponseBody;
|
|
314
|
+
static names(): {
|
|
315
|
+
[key: string]: string;
|
|
316
|
+
};
|
|
317
|
+
static types(): {
|
|
318
|
+
[key: string]: any;
|
|
319
|
+
};
|
|
320
|
+
constructor(map?: {
|
|
321
|
+
[key: string]: any;
|
|
322
|
+
});
|
|
323
|
+
}
|
|
251
324
|
export declare class CreateUserGroupRequest extends $tea.Model {
|
|
252
325
|
attributes?: CreateUserGroupRequestAttributes[];
|
|
253
326
|
description?: string;
|
|
@@ -451,6 +524,46 @@ export declare class DeletePrivateAccessTagResponse extends $tea.Model {
|
|
|
451
524
|
[key: string]: any;
|
|
452
525
|
});
|
|
453
526
|
}
|
|
527
|
+
export declare class DeleteRegistrationPoliciesRequest extends $tea.Model {
|
|
528
|
+
policyIds?: string[];
|
|
529
|
+
static names(): {
|
|
530
|
+
[key: string]: string;
|
|
531
|
+
};
|
|
532
|
+
static types(): {
|
|
533
|
+
[key: string]: any;
|
|
534
|
+
};
|
|
535
|
+
constructor(map?: {
|
|
536
|
+
[key: string]: any;
|
|
537
|
+
});
|
|
538
|
+
}
|
|
539
|
+
export declare class DeleteRegistrationPoliciesResponseBody extends $tea.Model {
|
|
540
|
+
requestId?: string;
|
|
541
|
+
static names(): {
|
|
542
|
+
[key: string]: string;
|
|
543
|
+
};
|
|
544
|
+
static types(): {
|
|
545
|
+
[key: string]: any;
|
|
546
|
+
};
|
|
547
|
+
constructor(map?: {
|
|
548
|
+
[key: string]: any;
|
|
549
|
+
});
|
|
550
|
+
}
|
|
551
|
+
export declare class DeleteRegistrationPoliciesResponse extends $tea.Model {
|
|
552
|
+
headers: {
|
|
553
|
+
[key: string]: string;
|
|
554
|
+
};
|
|
555
|
+
statusCode: number;
|
|
556
|
+
body: DeleteRegistrationPoliciesResponseBody;
|
|
557
|
+
static names(): {
|
|
558
|
+
[key: string]: string;
|
|
559
|
+
};
|
|
560
|
+
static types(): {
|
|
561
|
+
[key: string]: any;
|
|
562
|
+
};
|
|
563
|
+
constructor(map?: {
|
|
564
|
+
[key: string]: any;
|
|
565
|
+
});
|
|
566
|
+
}
|
|
454
567
|
export declare class DeleteUserGroupRequest extends $tea.Model {
|
|
455
568
|
userGroupId?: string;
|
|
456
569
|
static names(): {
|
|
@@ -668,6 +781,97 @@ export declare class GetPrivateAccessPolicyResponse extends $tea.Model {
|
|
|
668
781
|
[key: string]: any;
|
|
669
782
|
});
|
|
670
783
|
}
|
|
784
|
+
export declare class GetRegistrationPolicyRequest extends $tea.Model {
|
|
785
|
+
policyId?: string;
|
|
786
|
+
static names(): {
|
|
787
|
+
[key: string]: string;
|
|
788
|
+
};
|
|
789
|
+
static types(): {
|
|
790
|
+
[key: string]: any;
|
|
791
|
+
};
|
|
792
|
+
constructor(map?: {
|
|
793
|
+
[key: string]: any;
|
|
794
|
+
});
|
|
795
|
+
}
|
|
796
|
+
export declare class GetRegistrationPolicyResponseBody extends $tea.Model {
|
|
797
|
+
createTime?: string;
|
|
798
|
+
description?: string;
|
|
799
|
+
limitDetail?: GetRegistrationPolicyResponseBodyLimitDetail[];
|
|
800
|
+
matchMode?: string;
|
|
801
|
+
name?: string;
|
|
802
|
+
policyId?: string;
|
|
803
|
+
priority?: number;
|
|
804
|
+
requestId?: string;
|
|
805
|
+
status?: string;
|
|
806
|
+
userGroupIds?: string[];
|
|
807
|
+
whitelist?: string[];
|
|
808
|
+
static names(): {
|
|
809
|
+
[key: string]: string;
|
|
810
|
+
};
|
|
811
|
+
static types(): {
|
|
812
|
+
[key: string]: any;
|
|
813
|
+
};
|
|
814
|
+
constructor(map?: {
|
|
815
|
+
[key: string]: any;
|
|
816
|
+
});
|
|
817
|
+
}
|
|
818
|
+
export declare class GetRegistrationPolicyResponse extends $tea.Model {
|
|
819
|
+
headers: {
|
|
820
|
+
[key: string]: string;
|
|
821
|
+
};
|
|
822
|
+
statusCode: number;
|
|
823
|
+
body: GetRegistrationPolicyResponseBody;
|
|
824
|
+
static names(): {
|
|
825
|
+
[key: string]: string;
|
|
826
|
+
};
|
|
827
|
+
static types(): {
|
|
828
|
+
[key: string]: any;
|
|
829
|
+
};
|
|
830
|
+
constructor(map?: {
|
|
831
|
+
[key: string]: any;
|
|
832
|
+
});
|
|
833
|
+
}
|
|
834
|
+
export declare class GetUserDeviceRequest extends $tea.Model {
|
|
835
|
+
deviceTag?: string;
|
|
836
|
+
static names(): {
|
|
837
|
+
[key: string]: string;
|
|
838
|
+
};
|
|
839
|
+
static types(): {
|
|
840
|
+
[key: string]: any;
|
|
841
|
+
};
|
|
842
|
+
constructor(map?: {
|
|
843
|
+
[key: string]: any;
|
|
844
|
+
});
|
|
845
|
+
}
|
|
846
|
+
export declare class GetUserDeviceResponseBody extends $tea.Model {
|
|
847
|
+
device?: GetUserDeviceResponseBodyDevice;
|
|
848
|
+
requestId?: string;
|
|
849
|
+
static names(): {
|
|
850
|
+
[key: string]: string;
|
|
851
|
+
};
|
|
852
|
+
static types(): {
|
|
853
|
+
[key: string]: any;
|
|
854
|
+
};
|
|
855
|
+
constructor(map?: {
|
|
856
|
+
[key: string]: any;
|
|
857
|
+
});
|
|
858
|
+
}
|
|
859
|
+
export declare class GetUserDeviceResponse extends $tea.Model {
|
|
860
|
+
headers: {
|
|
861
|
+
[key: string]: string;
|
|
862
|
+
};
|
|
863
|
+
statusCode: number;
|
|
864
|
+
body: GetUserDeviceResponseBody;
|
|
865
|
+
static names(): {
|
|
866
|
+
[key: string]: string;
|
|
867
|
+
};
|
|
868
|
+
static types(): {
|
|
869
|
+
[key: string]: any;
|
|
870
|
+
};
|
|
871
|
+
constructor(map?: {
|
|
872
|
+
[key: string]: any;
|
|
873
|
+
});
|
|
874
|
+
}
|
|
671
875
|
export declare class GetUserGroupRequest extends $tea.Model {
|
|
672
876
|
userGroupId?: string;
|
|
673
877
|
static names(): {
|
|
@@ -918,6 +1122,57 @@ export declare class ListDynamicRoutesResponse extends $tea.Model {
|
|
|
918
1122
|
[key: string]: any;
|
|
919
1123
|
});
|
|
920
1124
|
}
|
|
1125
|
+
export declare class ListExcessiveDeviceRegistrationApplicationsRequest extends $tea.Model {
|
|
1126
|
+
applicationIds?: string[];
|
|
1127
|
+
currentPage?: number;
|
|
1128
|
+
department?: string;
|
|
1129
|
+
deviceTag?: string;
|
|
1130
|
+
hostname?: string;
|
|
1131
|
+
mac?: string;
|
|
1132
|
+
pageSize?: number;
|
|
1133
|
+
saseUserId?: string;
|
|
1134
|
+
statuses?: string[];
|
|
1135
|
+
username?: string;
|
|
1136
|
+
static names(): {
|
|
1137
|
+
[key: string]: string;
|
|
1138
|
+
};
|
|
1139
|
+
static types(): {
|
|
1140
|
+
[key: string]: any;
|
|
1141
|
+
};
|
|
1142
|
+
constructor(map?: {
|
|
1143
|
+
[key: string]: any;
|
|
1144
|
+
});
|
|
1145
|
+
}
|
|
1146
|
+
export declare class ListExcessiveDeviceRegistrationApplicationsResponseBody extends $tea.Model {
|
|
1147
|
+
applications?: ListExcessiveDeviceRegistrationApplicationsResponseBodyApplications[];
|
|
1148
|
+
requestId?: string;
|
|
1149
|
+
totalNum?: number;
|
|
1150
|
+
static names(): {
|
|
1151
|
+
[key: string]: string;
|
|
1152
|
+
};
|
|
1153
|
+
static types(): {
|
|
1154
|
+
[key: string]: any;
|
|
1155
|
+
};
|
|
1156
|
+
constructor(map?: {
|
|
1157
|
+
[key: string]: any;
|
|
1158
|
+
});
|
|
1159
|
+
}
|
|
1160
|
+
export declare class ListExcessiveDeviceRegistrationApplicationsResponse extends $tea.Model {
|
|
1161
|
+
headers: {
|
|
1162
|
+
[key: string]: string;
|
|
1163
|
+
};
|
|
1164
|
+
statusCode: number;
|
|
1165
|
+
body: ListExcessiveDeviceRegistrationApplicationsResponseBody;
|
|
1166
|
+
static names(): {
|
|
1167
|
+
[key: string]: string;
|
|
1168
|
+
};
|
|
1169
|
+
static types(): {
|
|
1170
|
+
[key: string]: any;
|
|
1171
|
+
};
|
|
1172
|
+
constructor(map?: {
|
|
1173
|
+
[key: string]: any;
|
|
1174
|
+
});
|
|
1175
|
+
}
|
|
921
1176
|
export declare class ListPolicesForPrivateAccessApplicationRequest extends $tea.Model {
|
|
922
1177
|
applicationIds?: string[];
|
|
923
1178
|
static names(): {
|
|
@@ -1270,8 +1525,16 @@ export declare class ListPrivateAccessTagsForDynamicRouteResponse extends $tea.M
|
|
|
1270
1525
|
[key: string]: any;
|
|
1271
1526
|
});
|
|
1272
1527
|
}
|
|
1273
|
-
export declare class
|
|
1274
|
-
|
|
1528
|
+
export declare class ListRegistrationPoliciesRequest extends $tea.Model {
|
|
1529
|
+
companyLimitType?: string;
|
|
1530
|
+
currentPage?: number;
|
|
1531
|
+
matchMode?: string;
|
|
1532
|
+
name?: string;
|
|
1533
|
+
pageSize?: number;
|
|
1534
|
+
personalLimitType?: string;
|
|
1535
|
+
policyIds?: string[];
|
|
1536
|
+
status?: string;
|
|
1537
|
+
userGroupId?: string;
|
|
1275
1538
|
static names(): {
|
|
1276
1539
|
[key: string]: string;
|
|
1277
1540
|
};
|
|
@@ -1282,9 +1545,10 @@ export declare class ListTagsForPrivateAccessApplicationRequest extends $tea.Mod
|
|
|
1282
1545
|
[key: string]: any;
|
|
1283
1546
|
});
|
|
1284
1547
|
}
|
|
1285
|
-
export declare class
|
|
1286
|
-
|
|
1548
|
+
export declare class ListRegistrationPoliciesResponseBody extends $tea.Model {
|
|
1549
|
+
policies?: ListRegistrationPoliciesResponseBodyPolicies[];
|
|
1287
1550
|
requestId?: string;
|
|
1551
|
+
totalNum?: string;
|
|
1288
1552
|
static names(): {
|
|
1289
1553
|
[key: string]: string;
|
|
1290
1554
|
};
|
|
@@ -1295,12 +1559,12 @@ export declare class ListTagsForPrivateAccessApplicationResponseBody extends $te
|
|
|
1295
1559
|
[key: string]: any;
|
|
1296
1560
|
});
|
|
1297
1561
|
}
|
|
1298
|
-
export declare class
|
|
1562
|
+
export declare class ListRegistrationPoliciesResponse extends $tea.Model {
|
|
1299
1563
|
headers: {
|
|
1300
1564
|
[key: string]: string;
|
|
1301
1565
|
};
|
|
1302
1566
|
statusCode: number;
|
|
1303
|
-
body:
|
|
1567
|
+
body: ListRegistrationPoliciesResponseBody;
|
|
1304
1568
|
static names(): {
|
|
1305
1569
|
[key: string]: string;
|
|
1306
1570
|
};
|
|
@@ -1311,8 +1575,8 @@ export declare class ListTagsForPrivateAccessApplicationResponse extends $tea.Mo
|
|
|
1311
1575
|
[key: string]: any;
|
|
1312
1576
|
});
|
|
1313
1577
|
}
|
|
1314
|
-
export declare class
|
|
1315
|
-
|
|
1578
|
+
export declare class ListRegistrationPoliciesForUserGroupRequest extends $tea.Model {
|
|
1579
|
+
userGroupIds?: string[];
|
|
1316
1580
|
static names(): {
|
|
1317
1581
|
[key: string]: string;
|
|
1318
1582
|
};
|
|
@@ -1323,9 +1587,9 @@ export declare class ListTagsForPrivateAccessPolicyRequest extends $tea.Model {
|
|
|
1323
1587
|
[key: string]: any;
|
|
1324
1588
|
});
|
|
1325
1589
|
}
|
|
1326
|
-
export declare class
|
|
1327
|
-
polices?: ListTagsForPrivateAccessPolicyResponseBodyPolices[];
|
|
1590
|
+
export declare class ListRegistrationPoliciesForUserGroupResponseBody extends $tea.Model {
|
|
1328
1591
|
requestId?: string;
|
|
1592
|
+
userGroups?: ListRegistrationPoliciesForUserGroupResponseBodyUserGroups[];
|
|
1329
1593
|
static names(): {
|
|
1330
1594
|
[key: string]: string;
|
|
1331
1595
|
};
|
|
@@ -1336,12 +1600,12 @@ export declare class ListTagsForPrivateAccessPolicyResponseBody extends $tea.Mod
|
|
|
1336
1600
|
[key: string]: any;
|
|
1337
1601
|
});
|
|
1338
1602
|
}
|
|
1339
|
-
export declare class
|
|
1603
|
+
export declare class ListRegistrationPoliciesForUserGroupResponse extends $tea.Model {
|
|
1340
1604
|
headers: {
|
|
1341
1605
|
[key: string]: string;
|
|
1342
1606
|
};
|
|
1343
1607
|
statusCode: number;
|
|
1344
|
-
body:
|
|
1608
|
+
body: ListRegistrationPoliciesForUserGroupResponseBody;
|
|
1345
1609
|
static names(): {
|
|
1346
1610
|
[key: string]: string;
|
|
1347
1611
|
};
|
|
@@ -1352,13 +1616,10 @@ export declare class ListTagsForPrivateAccessPolicyResponse extends $tea.Model {
|
|
|
1352
1616
|
[key: string]: any;
|
|
1353
1617
|
});
|
|
1354
1618
|
}
|
|
1355
|
-
export declare class
|
|
1356
|
-
attributeValue?: string;
|
|
1619
|
+
export declare class ListSoftwareForUserDeviceRequest extends $tea.Model {
|
|
1357
1620
|
currentPage?: number;
|
|
1358
|
-
|
|
1359
|
-
PAPolicyId?: string;
|
|
1621
|
+
deviceTag?: string;
|
|
1360
1622
|
pageSize?: number;
|
|
1361
|
-
userGroupIds?: string[];
|
|
1362
1623
|
static names(): {
|
|
1363
1624
|
[key: string]: string;
|
|
1364
1625
|
};
|
|
@@ -1369,10 +1630,10 @@ export declare class ListUserGroupsRequest extends $tea.Model {
|
|
|
1369
1630
|
[key: string]: any;
|
|
1370
1631
|
});
|
|
1371
1632
|
}
|
|
1372
|
-
export declare class
|
|
1633
|
+
export declare class ListSoftwareForUserDeviceResponseBody extends $tea.Model {
|
|
1373
1634
|
requestId?: string;
|
|
1635
|
+
software?: ListSoftwareForUserDeviceResponseBodySoftware[];
|
|
1374
1636
|
totalNum?: number;
|
|
1375
|
-
userGroups?: ListUserGroupsResponseBodyUserGroups[];
|
|
1376
1637
|
static names(): {
|
|
1377
1638
|
[key: string]: string;
|
|
1378
1639
|
};
|
|
@@ -1383,12 +1644,12 @@ export declare class ListUserGroupsResponseBody extends $tea.Model {
|
|
|
1383
1644
|
[key: string]: any;
|
|
1384
1645
|
});
|
|
1385
1646
|
}
|
|
1386
|
-
export declare class
|
|
1647
|
+
export declare class ListSoftwareForUserDeviceResponse extends $tea.Model {
|
|
1387
1648
|
headers: {
|
|
1388
1649
|
[key: string]: string;
|
|
1389
1650
|
};
|
|
1390
1651
|
statusCode: number;
|
|
1391
|
-
body:
|
|
1652
|
+
body: ListSoftwareForUserDeviceResponseBody;
|
|
1392
1653
|
static names(): {
|
|
1393
1654
|
[key: string]: string;
|
|
1394
1655
|
};
|
|
@@ -1399,8 +1660,8 @@ export declare class ListUserGroupsResponse extends $tea.Model {
|
|
|
1399
1660
|
[key: string]: any;
|
|
1400
1661
|
});
|
|
1401
1662
|
}
|
|
1402
|
-
export declare class
|
|
1403
|
-
|
|
1663
|
+
export declare class ListTagsForPrivateAccessApplicationRequest extends $tea.Model {
|
|
1664
|
+
applicationIds?: string[];
|
|
1404
1665
|
static names(): {
|
|
1405
1666
|
[key: string]: string;
|
|
1406
1667
|
};
|
|
@@ -1411,8 +1672,8 @@ export declare class ListUserGroupsForPrivateAccessPolicyRequest extends $tea.Mo
|
|
|
1411
1672
|
[key: string]: any;
|
|
1412
1673
|
});
|
|
1413
1674
|
}
|
|
1414
|
-
export declare class
|
|
1415
|
-
|
|
1675
|
+
export declare class ListTagsForPrivateAccessApplicationResponseBody extends $tea.Model {
|
|
1676
|
+
applications?: ListTagsForPrivateAccessApplicationResponseBodyApplications[];
|
|
1416
1677
|
requestId?: string;
|
|
1417
1678
|
static names(): {
|
|
1418
1679
|
[key: string]: string;
|
|
@@ -1424,12 +1685,12 @@ export declare class ListUserGroupsForPrivateAccessPolicyResponseBody extends $t
|
|
|
1424
1685
|
[key: string]: any;
|
|
1425
1686
|
});
|
|
1426
1687
|
}
|
|
1427
|
-
export declare class
|
|
1688
|
+
export declare class ListTagsForPrivateAccessApplicationResponse extends $tea.Model {
|
|
1428
1689
|
headers: {
|
|
1429
1690
|
[key: string]: string;
|
|
1430
1691
|
};
|
|
1431
1692
|
statusCode: number;
|
|
1432
|
-
body:
|
|
1693
|
+
body: ListTagsForPrivateAccessApplicationResponseBody;
|
|
1433
1694
|
static names(): {
|
|
1434
1695
|
[key: string]: string;
|
|
1435
1696
|
};
|
|
@@ -1440,13 +1701,241 @@ export declare class ListUserGroupsForPrivateAccessPolicyResponse extends $tea.M
|
|
|
1440
1701
|
[key: string]: any;
|
|
1441
1702
|
});
|
|
1442
1703
|
}
|
|
1443
|
-
export declare class
|
|
1444
|
-
|
|
1445
|
-
|
|
1446
|
-
|
|
1447
|
-
|
|
1448
|
-
|
|
1449
|
-
|
|
1704
|
+
export declare class ListTagsForPrivateAccessPolicyRequest extends $tea.Model {
|
|
1705
|
+
policyIds?: string[];
|
|
1706
|
+
static names(): {
|
|
1707
|
+
[key: string]: string;
|
|
1708
|
+
};
|
|
1709
|
+
static types(): {
|
|
1710
|
+
[key: string]: any;
|
|
1711
|
+
};
|
|
1712
|
+
constructor(map?: {
|
|
1713
|
+
[key: string]: any;
|
|
1714
|
+
});
|
|
1715
|
+
}
|
|
1716
|
+
export declare class ListTagsForPrivateAccessPolicyResponseBody extends $tea.Model {
|
|
1717
|
+
polices?: ListTagsForPrivateAccessPolicyResponseBodyPolices[];
|
|
1718
|
+
requestId?: string;
|
|
1719
|
+
static names(): {
|
|
1720
|
+
[key: string]: string;
|
|
1721
|
+
};
|
|
1722
|
+
static types(): {
|
|
1723
|
+
[key: string]: any;
|
|
1724
|
+
};
|
|
1725
|
+
constructor(map?: {
|
|
1726
|
+
[key: string]: any;
|
|
1727
|
+
});
|
|
1728
|
+
}
|
|
1729
|
+
export declare class ListTagsForPrivateAccessPolicyResponse extends $tea.Model {
|
|
1730
|
+
headers: {
|
|
1731
|
+
[key: string]: string;
|
|
1732
|
+
};
|
|
1733
|
+
statusCode: number;
|
|
1734
|
+
body: ListTagsForPrivateAccessPolicyResponseBody;
|
|
1735
|
+
static names(): {
|
|
1736
|
+
[key: string]: string;
|
|
1737
|
+
};
|
|
1738
|
+
static types(): {
|
|
1739
|
+
[key: string]: any;
|
|
1740
|
+
};
|
|
1741
|
+
constructor(map?: {
|
|
1742
|
+
[key: string]: any;
|
|
1743
|
+
});
|
|
1744
|
+
}
|
|
1745
|
+
export declare class ListUserDevicesRequest extends $tea.Model {
|
|
1746
|
+
appStatuses?: string[];
|
|
1747
|
+
currentPage?: number;
|
|
1748
|
+
department?: string;
|
|
1749
|
+
deviceBelong?: string;
|
|
1750
|
+
deviceStatuses?: string[];
|
|
1751
|
+
deviceTags?: string[];
|
|
1752
|
+
deviceTypes?: string[];
|
|
1753
|
+
dlpStatuses?: string[];
|
|
1754
|
+
hostname?: string;
|
|
1755
|
+
iaStatuses?: string[];
|
|
1756
|
+
mac?: string;
|
|
1757
|
+
nacStatuses?: string[];
|
|
1758
|
+
paStatuses?: string[];
|
|
1759
|
+
pageSize?: number;
|
|
1760
|
+
saseUserId?: string;
|
|
1761
|
+
sharingStatus?: boolean;
|
|
1762
|
+
username?: string;
|
|
1763
|
+
static names(): {
|
|
1764
|
+
[key: string]: string;
|
|
1765
|
+
};
|
|
1766
|
+
static types(): {
|
|
1767
|
+
[key: string]: any;
|
|
1768
|
+
};
|
|
1769
|
+
constructor(map?: {
|
|
1770
|
+
[key: string]: any;
|
|
1771
|
+
});
|
|
1772
|
+
}
|
|
1773
|
+
export declare class ListUserDevicesResponseBody extends $tea.Model {
|
|
1774
|
+
devices?: ListUserDevicesResponseBodyDevices[];
|
|
1775
|
+
requestId?: string;
|
|
1776
|
+
totalNum?: number;
|
|
1777
|
+
static names(): {
|
|
1778
|
+
[key: string]: string;
|
|
1779
|
+
};
|
|
1780
|
+
static types(): {
|
|
1781
|
+
[key: string]: any;
|
|
1782
|
+
};
|
|
1783
|
+
constructor(map?: {
|
|
1784
|
+
[key: string]: any;
|
|
1785
|
+
});
|
|
1786
|
+
}
|
|
1787
|
+
export declare class ListUserDevicesResponse extends $tea.Model {
|
|
1788
|
+
headers: {
|
|
1789
|
+
[key: string]: string;
|
|
1790
|
+
};
|
|
1791
|
+
statusCode: number;
|
|
1792
|
+
body: ListUserDevicesResponseBody;
|
|
1793
|
+
static names(): {
|
|
1794
|
+
[key: string]: string;
|
|
1795
|
+
};
|
|
1796
|
+
static types(): {
|
|
1797
|
+
[key: string]: any;
|
|
1798
|
+
};
|
|
1799
|
+
constructor(map?: {
|
|
1800
|
+
[key: string]: any;
|
|
1801
|
+
});
|
|
1802
|
+
}
|
|
1803
|
+
export declare class ListUserGroupsRequest extends $tea.Model {
|
|
1804
|
+
attributeValue?: string;
|
|
1805
|
+
currentPage?: number;
|
|
1806
|
+
name?: string;
|
|
1807
|
+
PAPolicyId?: string;
|
|
1808
|
+
pageSize?: number;
|
|
1809
|
+
userGroupIds?: string[];
|
|
1810
|
+
static names(): {
|
|
1811
|
+
[key: string]: string;
|
|
1812
|
+
};
|
|
1813
|
+
static types(): {
|
|
1814
|
+
[key: string]: any;
|
|
1815
|
+
};
|
|
1816
|
+
constructor(map?: {
|
|
1817
|
+
[key: string]: any;
|
|
1818
|
+
});
|
|
1819
|
+
}
|
|
1820
|
+
export declare class ListUserGroupsResponseBody extends $tea.Model {
|
|
1821
|
+
requestId?: string;
|
|
1822
|
+
totalNum?: number;
|
|
1823
|
+
userGroups?: ListUserGroupsResponseBodyUserGroups[];
|
|
1824
|
+
static names(): {
|
|
1825
|
+
[key: string]: string;
|
|
1826
|
+
};
|
|
1827
|
+
static types(): {
|
|
1828
|
+
[key: string]: any;
|
|
1829
|
+
};
|
|
1830
|
+
constructor(map?: {
|
|
1831
|
+
[key: string]: any;
|
|
1832
|
+
});
|
|
1833
|
+
}
|
|
1834
|
+
export declare class ListUserGroupsResponse extends $tea.Model {
|
|
1835
|
+
headers: {
|
|
1836
|
+
[key: string]: string;
|
|
1837
|
+
};
|
|
1838
|
+
statusCode: number;
|
|
1839
|
+
body: ListUserGroupsResponseBody;
|
|
1840
|
+
static names(): {
|
|
1841
|
+
[key: string]: string;
|
|
1842
|
+
};
|
|
1843
|
+
static types(): {
|
|
1844
|
+
[key: string]: any;
|
|
1845
|
+
};
|
|
1846
|
+
constructor(map?: {
|
|
1847
|
+
[key: string]: any;
|
|
1848
|
+
});
|
|
1849
|
+
}
|
|
1850
|
+
export declare class ListUserGroupsForPrivateAccessPolicyRequest extends $tea.Model {
|
|
1851
|
+
policyIds?: string[];
|
|
1852
|
+
static names(): {
|
|
1853
|
+
[key: string]: string;
|
|
1854
|
+
};
|
|
1855
|
+
static types(): {
|
|
1856
|
+
[key: string]: any;
|
|
1857
|
+
};
|
|
1858
|
+
constructor(map?: {
|
|
1859
|
+
[key: string]: any;
|
|
1860
|
+
});
|
|
1861
|
+
}
|
|
1862
|
+
export declare class ListUserGroupsForPrivateAccessPolicyResponseBody extends $tea.Model {
|
|
1863
|
+
polices?: ListUserGroupsForPrivateAccessPolicyResponseBodyPolices[];
|
|
1864
|
+
requestId?: string;
|
|
1865
|
+
static names(): {
|
|
1866
|
+
[key: string]: string;
|
|
1867
|
+
};
|
|
1868
|
+
static types(): {
|
|
1869
|
+
[key: string]: any;
|
|
1870
|
+
};
|
|
1871
|
+
constructor(map?: {
|
|
1872
|
+
[key: string]: any;
|
|
1873
|
+
});
|
|
1874
|
+
}
|
|
1875
|
+
export declare class ListUserGroupsForPrivateAccessPolicyResponse extends $tea.Model {
|
|
1876
|
+
headers: {
|
|
1877
|
+
[key: string]: string;
|
|
1878
|
+
};
|
|
1879
|
+
statusCode: number;
|
|
1880
|
+
body: ListUserGroupsForPrivateAccessPolicyResponseBody;
|
|
1881
|
+
static names(): {
|
|
1882
|
+
[key: string]: string;
|
|
1883
|
+
};
|
|
1884
|
+
static types(): {
|
|
1885
|
+
[key: string]: any;
|
|
1886
|
+
};
|
|
1887
|
+
constructor(map?: {
|
|
1888
|
+
[key: string]: any;
|
|
1889
|
+
});
|
|
1890
|
+
}
|
|
1891
|
+
export declare class ListUserGroupsForRegistrationPolicyRequest extends $tea.Model {
|
|
1892
|
+
policyIds?: string[];
|
|
1893
|
+
static names(): {
|
|
1894
|
+
[key: string]: string;
|
|
1895
|
+
};
|
|
1896
|
+
static types(): {
|
|
1897
|
+
[key: string]: any;
|
|
1898
|
+
};
|
|
1899
|
+
constructor(map?: {
|
|
1900
|
+
[key: string]: any;
|
|
1901
|
+
});
|
|
1902
|
+
}
|
|
1903
|
+
export declare class ListUserGroupsForRegistrationPolicyResponseBody extends $tea.Model {
|
|
1904
|
+
policies?: ListUserGroupsForRegistrationPolicyResponseBodyPolicies[];
|
|
1905
|
+
requestId?: string;
|
|
1906
|
+
static names(): {
|
|
1907
|
+
[key: string]: string;
|
|
1908
|
+
};
|
|
1909
|
+
static types(): {
|
|
1910
|
+
[key: string]: any;
|
|
1911
|
+
};
|
|
1912
|
+
constructor(map?: {
|
|
1913
|
+
[key: string]: any;
|
|
1914
|
+
});
|
|
1915
|
+
}
|
|
1916
|
+
export declare class ListUserGroupsForRegistrationPolicyResponse extends $tea.Model {
|
|
1917
|
+
headers: {
|
|
1918
|
+
[key: string]: string;
|
|
1919
|
+
};
|
|
1920
|
+
statusCode: number;
|
|
1921
|
+
body: ListUserGroupsForRegistrationPolicyResponseBody;
|
|
1922
|
+
static names(): {
|
|
1923
|
+
[key: string]: string;
|
|
1924
|
+
};
|
|
1925
|
+
static types(): {
|
|
1926
|
+
[key: string]: any;
|
|
1927
|
+
};
|
|
1928
|
+
constructor(map?: {
|
|
1929
|
+
[key: string]: any;
|
|
1930
|
+
});
|
|
1931
|
+
}
|
|
1932
|
+
export declare class UpdateDynamicRouteRequest extends $tea.Model {
|
|
1933
|
+
applicationIds?: string[];
|
|
1934
|
+
applicationType?: string;
|
|
1935
|
+
description?: string;
|
|
1936
|
+
dynamicRouteId?: string;
|
|
1937
|
+
dynamicRouteType?: string;
|
|
1938
|
+
modifyType?: string;
|
|
1450
1939
|
name?: string;
|
|
1451
1940
|
nextHop?: string;
|
|
1452
1941
|
priority?: number;
|
|
@@ -1491,6 +1980,48 @@ export declare class UpdateDynamicRouteResponse extends $tea.Model {
|
|
|
1491
1980
|
[key: string]: any;
|
|
1492
1981
|
});
|
|
1493
1982
|
}
|
|
1983
|
+
export declare class UpdateExcessiveDeviceRegistrationApplicationsStatusRequest extends $tea.Model {
|
|
1984
|
+
applicationIds?: string[];
|
|
1985
|
+
status?: string;
|
|
1986
|
+
static names(): {
|
|
1987
|
+
[key: string]: string;
|
|
1988
|
+
};
|
|
1989
|
+
static types(): {
|
|
1990
|
+
[key: string]: any;
|
|
1991
|
+
};
|
|
1992
|
+
constructor(map?: {
|
|
1993
|
+
[key: string]: any;
|
|
1994
|
+
});
|
|
1995
|
+
}
|
|
1996
|
+
export declare class UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBody extends $tea.Model {
|
|
1997
|
+
applications?: UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBodyApplications[];
|
|
1998
|
+
requestId?: string;
|
|
1999
|
+
static names(): {
|
|
2000
|
+
[key: string]: string;
|
|
2001
|
+
};
|
|
2002
|
+
static types(): {
|
|
2003
|
+
[key: string]: any;
|
|
2004
|
+
};
|
|
2005
|
+
constructor(map?: {
|
|
2006
|
+
[key: string]: any;
|
|
2007
|
+
});
|
|
2008
|
+
}
|
|
2009
|
+
export declare class UpdateExcessiveDeviceRegistrationApplicationsStatusResponse extends $tea.Model {
|
|
2010
|
+
headers: {
|
|
2011
|
+
[key: string]: string;
|
|
2012
|
+
};
|
|
2013
|
+
statusCode: number;
|
|
2014
|
+
body: UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBody;
|
|
2015
|
+
static names(): {
|
|
2016
|
+
[key: string]: string;
|
|
2017
|
+
};
|
|
2018
|
+
static types(): {
|
|
2019
|
+
[key: string]: any;
|
|
2020
|
+
};
|
|
2021
|
+
constructor(map?: {
|
|
2022
|
+
[key: string]: any;
|
|
2023
|
+
});
|
|
2024
|
+
}
|
|
1494
2025
|
export declare class UpdatePrivateAccessApplicationRequest extends $tea.Model {
|
|
1495
2026
|
addresses?: string[];
|
|
1496
2027
|
applicationId?: string;
|
|
@@ -1589,6 +2120,165 @@ export declare class UpdatePrivateAccessPolicyResponse extends $tea.Model {
|
|
|
1589
2120
|
[key: string]: any;
|
|
1590
2121
|
});
|
|
1591
2122
|
}
|
|
2123
|
+
export declare class UpdateRegistrationPolicyRequest extends $tea.Model {
|
|
2124
|
+
companyLimitCount?: UpdateRegistrationPolicyRequestCompanyLimitCount;
|
|
2125
|
+
companyLimitType?: string;
|
|
2126
|
+
description?: string;
|
|
2127
|
+
matchMode?: string;
|
|
2128
|
+
name?: string;
|
|
2129
|
+
personalLimitCount?: UpdateRegistrationPolicyRequestPersonalLimitCount;
|
|
2130
|
+
personalLimitType?: string;
|
|
2131
|
+
policyId?: string;
|
|
2132
|
+
priority?: number;
|
|
2133
|
+
status?: string;
|
|
2134
|
+
userGroupIds?: string[];
|
|
2135
|
+
whitelist?: string[];
|
|
2136
|
+
static names(): {
|
|
2137
|
+
[key: string]: string;
|
|
2138
|
+
};
|
|
2139
|
+
static types(): {
|
|
2140
|
+
[key: string]: any;
|
|
2141
|
+
};
|
|
2142
|
+
constructor(map?: {
|
|
2143
|
+
[key: string]: any;
|
|
2144
|
+
});
|
|
2145
|
+
}
|
|
2146
|
+
export declare class UpdateRegistrationPolicyShrinkRequest extends $tea.Model {
|
|
2147
|
+
companyLimitCountShrink?: string;
|
|
2148
|
+
companyLimitType?: string;
|
|
2149
|
+
description?: string;
|
|
2150
|
+
matchMode?: string;
|
|
2151
|
+
name?: string;
|
|
2152
|
+
personalLimitCountShrink?: string;
|
|
2153
|
+
personalLimitType?: string;
|
|
2154
|
+
policyId?: string;
|
|
2155
|
+
priority?: number;
|
|
2156
|
+
status?: string;
|
|
2157
|
+
userGroupIds?: string[];
|
|
2158
|
+
whitelist?: string[];
|
|
2159
|
+
static names(): {
|
|
2160
|
+
[key: string]: string;
|
|
2161
|
+
};
|
|
2162
|
+
static types(): {
|
|
2163
|
+
[key: string]: any;
|
|
2164
|
+
};
|
|
2165
|
+
constructor(map?: {
|
|
2166
|
+
[key: string]: any;
|
|
2167
|
+
});
|
|
2168
|
+
}
|
|
2169
|
+
export declare class UpdateRegistrationPolicyResponseBody extends $tea.Model {
|
|
2170
|
+
policy?: UpdateRegistrationPolicyResponseBodyPolicy;
|
|
2171
|
+
requestId?: string;
|
|
2172
|
+
static names(): {
|
|
2173
|
+
[key: string]: string;
|
|
2174
|
+
};
|
|
2175
|
+
static types(): {
|
|
2176
|
+
[key: string]: any;
|
|
2177
|
+
};
|
|
2178
|
+
constructor(map?: {
|
|
2179
|
+
[key: string]: any;
|
|
2180
|
+
});
|
|
2181
|
+
}
|
|
2182
|
+
export declare class UpdateRegistrationPolicyResponse extends $tea.Model {
|
|
2183
|
+
headers: {
|
|
2184
|
+
[key: string]: string;
|
|
2185
|
+
};
|
|
2186
|
+
statusCode: number;
|
|
2187
|
+
body: UpdateRegistrationPolicyResponseBody;
|
|
2188
|
+
static names(): {
|
|
2189
|
+
[key: string]: string;
|
|
2190
|
+
};
|
|
2191
|
+
static types(): {
|
|
2192
|
+
[key: string]: any;
|
|
2193
|
+
};
|
|
2194
|
+
constructor(map?: {
|
|
2195
|
+
[key: string]: any;
|
|
2196
|
+
});
|
|
2197
|
+
}
|
|
2198
|
+
export declare class UpdateUserDevicesSharingStatusRequest extends $tea.Model {
|
|
2199
|
+
deviceTags?: string[];
|
|
2200
|
+
sharingStatus?: boolean;
|
|
2201
|
+
static names(): {
|
|
2202
|
+
[key: string]: string;
|
|
2203
|
+
};
|
|
2204
|
+
static types(): {
|
|
2205
|
+
[key: string]: any;
|
|
2206
|
+
};
|
|
2207
|
+
constructor(map?: {
|
|
2208
|
+
[key: string]: any;
|
|
2209
|
+
});
|
|
2210
|
+
}
|
|
2211
|
+
export declare class UpdateUserDevicesSharingStatusResponseBody extends $tea.Model {
|
|
2212
|
+
devices?: UpdateUserDevicesSharingStatusResponseBodyDevices[];
|
|
2213
|
+
requestId?: string;
|
|
2214
|
+
static names(): {
|
|
2215
|
+
[key: string]: string;
|
|
2216
|
+
};
|
|
2217
|
+
static types(): {
|
|
2218
|
+
[key: string]: any;
|
|
2219
|
+
};
|
|
2220
|
+
constructor(map?: {
|
|
2221
|
+
[key: string]: any;
|
|
2222
|
+
});
|
|
2223
|
+
}
|
|
2224
|
+
export declare class UpdateUserDevicesSharingStatusResponse extends $tea.Model {
|
|
2225
|
+
headers: {
|
|
2226
|
+
[key: string]: string;
|
|
2227
|
+
};
|
|
2228
|
+
statusCode: number;
|
|
2229
|
+
body: UpdateUserDevicesSharingStatusResponseBody;
|
|
2230
|
+
static names(): {
|
|
2231
|
+
[key: string]: string;
|
|
2232
|
+
};
|
|
2233
|
+
static types(): {
|
|
2234
|
+
[key: string]: any;
|
|
2235
|
+
};
|
|
2236
|
+
constructor(map?: {
|
|
2237
|
+
[key: string]: any;
|
|
2238
|
+
});
|
|
2239
|
+
}
|
|
2240
|
+
export declare class UpdateUserDevicesStatusRequest extends $tea.Model {
|
|
2241
|
+
deviceAction?: string;
|
|
2242
|
+
deviceTags?: string[];
|
|
2243
|
+
static names(): {
|
|
2244
|
+
[key: string]: string;
|
|
2245
|
+
};
|
|
2246
|
+
static types(): {
|
|
2247
|
+
[key: string]: any;
|
|
2248
|
+
};
|
|
2249
|
+
constructor(map?: {
|
|
2250
|
+
[key: string]: any;
|
|
2251
|
+
});
|
|
2252
|
+
}
|
|
2253
|
+
export declare class UpdateUserDevicesStatusResponseBody extends $tea.Model {
|
|
2254
|
+
devices?: UpdateUserDevicesStatusResponseBodyDevices[];
|
|
2255
|
+
requestId?: string;
|
|
2256
|
+
static names(): {
|
|
2257
|
+
[key: string]: string;
|
|
2258
|
+
};
|
|
2259
|
+
static types(): {
|
|
2260
|
+
[key: string]: any;
|
|
2261
|
+
};
|
|
2262
|
+
constructor(map?: {
|
|
2263
|
+
[key: string]: any;
|
|
2264
|
+
});
|
|
2265
|
+
}
|
|
2266
|
+
export declare class UpdateUserDevicesStatusResponse extends $tea.Model {
|
|
2267
|
+
headers: {
|
|
2268
|
+
[key: string]: string;
|
|
2269
|
+
};
|
|
2270
|
+
statusCode: number;
|
|
2271
|
+
body: UpdateUserDevicesStatusResponseBody;
|
|
2272
|
+
static names(): {
|
|
2273
|
+
[key: string]: string;
|
|
2274
|
+
};
|
|
2275
|
+
static types(): {
|
|
2276
|
+
[key: string]: any;
|
|
2277
|
+
};
|
|
2278
|
+
constructor(map?: {
|
|
2279
|
+
[key: string]: any;
|
|
2280
|
+
});
|
|
2281
|
+
}
|
|
1592
2282
|
export declare class UpdateUserGroupRequest extends $tea.Model {
|
|
1593
2283
|
attributes?: UpdateUserGroupRequestAttributes[];
|
|
1594
2284
|
description?: string;
|
|
@@ -1660,6 +2350,83 @@ export declare class CreatePrivateAccessPolicyRequestCustomUserAttributes extend
|
|
|
1660
2350
|
[key: string]: any;
|
|
1661
2351
|
});
|
|
1662
2352
|
}
|
|
2353
|
+
export declare class CreateRegistrationPolicyRequestCompanyLimitCount extends $tea.Model {
|
|
2354
|
+
all?: number;
|
|
2355
|
+
mobile?: number;
|
|
2356
|
+
PC?: number;
|
|
2357
|
+
static names(): {
|
|
2358
|
+
[key: string]: string;
|
|
2359
|
+
};
|
|
2360
|
+
static types(): {
|
|
2361
|
+
[key: string]: any;
|
|
2362
|
+
};
|
|
2363
|
+
constructor(map?: {
|
|
2364
|
+
[key: string]: any;
|
|
2365
|
+
});
|
|
2366
|
+
}
|
|
2367
|
+
export declare class CreateRegistrationPolicyRequestPersonalLimitCount extends $tea.Model {
|
|
2368
|
+
all?: number;
|
|
2369
|
+
mobile?: number;
|
|
2370
|
+
PC?: number;
|
|
2371
|
+
static names(): {
|
|
2372
|
+
[key: string]: string;
|
|
2373
|
+
};
|
|
2374
|
+
static types(): {
|
|
2375
|
+
[key: string]: any;
|
|
2376
|
+
};
|
|
2377
|
+
constructor(map?: {
|
|
2378
|
+
[key: string]: any;
|
|
2379
|
+
});
|
|
2380
|
+
}
|
|
2381
|
+
export declare class CreateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount extends $tea.Model {
|
|
2382
|
+
all?: number;
|
|
2383
|
+
mobile?: number;
|
|
2384
|
+
PC?: number;
|
|
2385
|
+
static names(): {
|
|
2386
|
+
[key: string]: string;
|
|
2387
|
+
};
|
|
2388
|
+
static types(): {
|
|
2389
|
+
[key: string]: any;
|
|
2390
|
+
};
|
|
2391
|
+
constructor(map?: {
|
|
2392
|
+
[key: string]: any;
|
|
2393
|
+
});
|
|
2394
|
+
}
|
|
2395
|
+
export declare class CreateRegistrationPolicyResponseBodyPolicyLimitDetail extends $tea.Model {
|
|
2396
|
+
deviceBelong?: string;
|
|
2397
|
+
limitCount?: CreateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount;
|
|
2398
|
+
limitType?: string;
|
|
2399
|
+
static names(): {
|
|
2400
|
+
[key: string]: string;
|
|
2401
|
+
};
|
|
2402
|
+
static types(): {
|
|
2403
|
+
[key: string]: any;
|
|
2404
|
+
};
|
|
2405
|
+
constructor(map?: {
|
|
2406
|
+
[key: string]: any;
|
|
2407
|
+
});
|
|
2408
|
+
}
|
|
2409
|
+
export declare class CreateRegistrationPolicyResponseBodyPolicy extends $tea.Model {
|
|
2410
|
+
createTime?: string;
|
|
2411
|
+
description?: string;
|
|
2412
|
+
limitDetail?: CreateRegistrationPolicyResponseBodyPolicyLimitDetail[];
|
|
2413
|
+
matchMode?: string;
|
|
2414
|
+
name?: string;
|
|
2415
|
+
policyId?: string;
|
|
2416
|
+
priority?: string;
|
|
2417
|
+
status?: string;
|
|
2418
|
+
userGroupIds?: string[];
|
|
2419
|
+
whitelist?: string[];
|
|
2420
|
+
static names(): {
|
|
2421
|
+
[key: string]: string;
|
|
2422
|
+
};
|
|
2423
|
+
static types(): {
|
|
2424
|
+
[key: string]: any;
|
|
2425
|
+
};
|
|
2426
|
+
constructor(map?: {
|
|
2427
|
+
[key: string]: any;
|
|
2428
|
+
});
|
|
2429
|
+
}
|
|
1663
2430
|
export declare class CreateUserGroupRequestAttributes extends $tea.Model {
|
|
1664
2431
|
idpId?: number;
|
|
1665
2432
|
relation?: string;
|
|
@@ -1772,6 +2539,84 @@ export declare class GetPrivateAccessPolicyResponseBodyPolicy extends $tea.Model
|
|
|
1772
2539
|
[key: string]: any;
|
|
1773
2540
|
});
|
|
1774
2541
|
}
|
|
2542
|
+
export declare class GetRegistrationPolicyResponseBodyLimitDetailLimitCount extends $tea.Model {
|
|
2543
|
+
all?: number;
|
|
2544
|
+
mobile?: number;
|
|
2545
|
+
PC?: number;
|
|
2546
|
+
static names(): {
|
|
2547
|
+
[key: string]: string;
|
|
2548
|
+
};
|
|
2549
|
+
static types(): {
|
|
2550
|
+
[key: string]: any;
|
|
2551
|
+
};
|
|
2552
|
+
constructor(map?: {
|
|
2553
|
+
[key: string]: any;
|
|
2554
|
+
});
|
|
2555
|
+
}
|
|
2556
|
+
export declare class GetRegistrationPolicyResponseBodyLimitDetail extends $tea.Model {
|
|
2557
|
+
deviceBelong?: string;
|
|
2558
|
+
limitCount?: GetRegistrationPolicyResponseBodyLimitDetailLimitCount;
|
|
2559
|
+
limitType?: string;
|
|
2560
|
+
static names(): {
|
|
2561
|
+
[key: string]: string;
|
|
2562
|
+
};
|
|
2563
|
+
static types(): {
|
|
2564
|
+
[key: string]: any;
|
|
2565
|
+
};
|
|
2566
|
+
constructor(map?: {
|
|
2567
|
+
[key: string]: any;
|
|
2568
|
+
});
|
|
2569
|
+
}
|
|
2570
|
+
export declare class GetUserDeviceResponseBodyDeviceHistoryUsers extends $tea.Model {
|
|
2571
|
+
saseUserId?: string;
|
|
2572
|
+
username?: string;
|
|
2573
|
+
static names(): {
|
|
2574
|
+
[key: string]: string;
|
|
2575
|
+
};
|
|
2576
|
+
static types(): {
|
|
2577
|
+
[key: string]: any;
|
|
2578
|
+
};
|
|
2579
|
+
constructor(map?: {
|
|
2580
|
+
[key: string]: any;
|
|
2581
|
+
});
|
|
2582
|
+
}
|
|
2583
|
+
export declare class GetUserDeviceResponseBodyDevice extends $tea.Model {
|
|
2584
|
+
appStatus?: string;
|
|
2585
|
+
appVersion?: string;
|
|
2586
|
+
CPU?: string;
|
|
2587
|
+
createTime?: string;
|
|
2588
|
+
department?: string;
|
|
2589
|
+
deviceBelong?: string;
|
|
2590
|
+
deviceModel?: string;
|
|
2591
|
+
deviceStatus?: string;
|
|
2592
|
+
deviceTag?: string;
|
|
2593
|
+
deviceType?: string;
|
|
2594
|
+
deviceVersion?: string;
|
|
2595
|
+
disk?: string;
|
|
2596
|
+
dlpStatus?: string;
|
|
2597
|
+
historyUsers?: GetUserDeviceResponseBodyDeviceHistoryUsers[];
|
|
2598
|
+
hostname?: string;
|
|
2599
|
+
iaStatus?: string;
|
|
2600
|
+
innerIP?: string;
|
|
2601
|
+
mac?: string;
|
|
2602
|
+
memory?: string;
|
|
2603
|
+
nacStatus?: string;
|
|
2604
|
+
paStatus?: string;
|
|
2605
|
+
saseUserId?: string;
|
|
2606
|
+
sharingStatus?: boolean;
|
|
2607
|
+
srcIP?: string;
|
|
2608
|
+
updateTime?: string;
|
|
2609
|
+
username?: string;
|
|
2610
|
+
static names(): {
|
|
2611
|
+
[key: string]: string;
|
|
2612
|
+
};
|
|
2613
|
+
static types(): {
|
|
2614
|
+
[key: string]: any;
|
|
2615
|
+
};
|
|
2616
|
+
constructor(map?: {
|
|
2617
|
+
[key: string]: any;
|
|
2618
|
+
});
|
|
2619
|
+
}
|
|
1775
2620
|
export declare class GetUserGroupResponseBodyUserGroupAttributes extends $tea.Model {
|
|
1776
2621
|
idpId?: number;
|
|
1777
2622
|
relation?: string;
|
|
@@ -1977,6 +2822,29 @@ export declare class ListDynamicRoutesResponseBodyDynamicRoutes extends $tea.Mod
|
|
|
1977
2822
|
[key: string]: any;
|
|
1978
2823
|
});
|
|
1979
2824
|
}
|
|
2825
|
+
export declare class ListExcessiveDeviceRegistrationApplicationsResponseBodyApplications extends $tea.Model {
|
|
2826
|
+
applicationId?: string;
|
|
2827
|
+
createTime?: string;
|
|
2828
|
+
department?: string;
|
|
2829
|
+
description?: string;
|
|
2830
|
+
deviceTag?: string;
|
|
2831
|
+
deviceType?: string;
|
|
2832
|
+
hostname?: string;
|
|
2833
|
+
isUsed?: boolean;
|
|
2834
|
+
mac?: string;
|
|
2835
|
+
saseUserId?: string;
|
|
2836
|
+
status?: string;
|
|
2837
|
+
username?: string;
|
|
2838
|
+
static names(): {
|
|
2839
|
+
[key: string]: string;
|
|
2840
|
+
};
|
|
2841
|
+
static types(): {
|
|
2842
|
+
[key: string]: any;
|
|
2843
|
+
};
|
|
2844
|
+
constructor(map?: {
|
|
2845
|
+
[key: string]: any;
|
|
2846
|
+
});
|
|
2847
|
+
}
|
|
1980
2848
|
export declare class ListPolicesForPrivateAccessApplicationResponseBodyApplicationsPoliciesCustomUserAttributes extends $tea.Model {
|
|
1981
2849
|
idpId?: number;
|
|
1982
2850
|
relation?: string;
|
|
@@ -2268,6 +3136,131 @@ export declare class ListPrivateAccessTagsForDynamicRouteResponseBodyDynamicRout
|
|
|
2268
3136
|
[key: string]: any;
|
|
2269
3137
|
});
|
|
2270
3138
|
}
|
|
3139
|
+
export declare class ListRegistrationPoliciesResponseBodyPoliciesLimitDetailLimitCount extends $tea.Model {
|
|
3140
|
+
all?: number;
|
|
3141
|
+
mobile?: number;
|
|
3142
|
+
PC?: number;
|
|
3143
|
+
static names(): {
|
|
3144
|
+
[key: string]: string;
|
|
3145
|
+
};
|
|
3146
|
+
static types(): {
|
|
3147
|
+
[key: string]: any;
|
|
3148
|
+
};
|
|
3149
|
+
constructor(map?: {
|
|
3150
|
+
[key: string]: any;
|
|
3151
|
+
});
|
|
3152
|
+
}
|
|
3153
|
+
export declare class ListRegistrationPoliciesResponseBodyPoliciesLimitDetail extends $tea.Model {
|
|
3154
|
+
deviceBelong?: string;
|
|
3155
|
+
limitCount?: ListRegistrationPoliciesResponseBodyPoliciesLimitDetailLimitCount;
|
|
3156
|
+
limitType?: string;
|
|
3157
|
+
static names(): {
|
|
3158
|
+
[key: string]: string;
|
|
3159
|
+
};
|
|
3160
|
+
static types(): {
|
|
3161
|
+
[key: string]: any;
|
|
3162
|
+
};
|
|
3163
|
+
constructor(map?: {
|
|
3164
|
+
[key: string]: any;
|
|
3165
|
+
});
|
|
3166
|
+
}
|
|
3167
|
+
export declare class ListRegistrationPoliciesResponseBodyPolicies extends $tea.Model {
|
|
3168
|
+
createTime?: string;
|
|
3169
|
+
description?: string;
|
|
3170
|
+
limitDetail?: ListRegistrationPoliciesResponseBodyPoliciesLimitDetail[];
|
|
3171
|
+
matchMode?: string;
|
|
3172
|
+
name?: string;
|
|
3173
|
+
policyId?: string;
|
|
3174
|
+
priority?: number;
|
|
3175
|
+
status?: string;
|
|
3176
|
+
userGroupIds?: string[];
|
|
3177
|
+
whitelist?: string[];
|
|
3178
|
+
static names(): {
|
|
3179
|
+
[key: string]: string;
|
|
3180
|
+
};
|
|
3181
|
+
static types(): {
|
|
3182
|
+
[key: string]: any;
|
|
3183
|
+
};
|
|
3184
|
+
constructor(map?: {
|
|
3185
|
+
[key: string]: any;
|
|
3186
|
+
});
|
|
3187
|
+
}
|
|
3188
|
+
export declare class ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetailLimitCount extends $tea.Model {
|
|
3189
|
+
all?: string;
|
|
3190
|
+
mobile?: string;
|
|
3191
|
+
PC?: string;
|
|
3192
|
+
static names(): {
|
|
3193
|
+
[key: string]: string;
|
|
3194
|
+
};
|
|
3195
|
+
static types(): {
|
|
3196
|
+
[key: string]: any;
|
|
3197
|
+
};
|
|
3198
|
+
constructor(map?: {
|
|
3199
|
+
[key: string]: any;
|
|
3200
|
+
});
|
|
3201
|
+
}
|
|
3202
|
+
export declare class ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetail extends $tea.Model {
|
|
3203
|
+
deviceBelong?: string;
|
|
3204
|
+
limitCount?: ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetailLimitCount;
|
|
3205
|
+
limitType?: string;
|
|
3206
|
+
static names(): {
|
|
3207
|
+
[key: string]: string;
|
|
3208
|
+
};
|
|
3209
|
+
static types(): {
|
|
3210
|
+
[key: string]: any;
|
|
3211
|
+
};
|
|
3212
|
+
constructor(map?: {
|
|
3213
|
+
[key: string]: any;
|
|
3214
|
+
});
|
|
3215
|
+
}
|
|
3216
|
+
export declare class ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPolicies extends $tea.Model {
|
|
3217
|
+
createTime?: string;
|
|
3218
|
+
description?: string;
|
|
3219
|
+
limitDetail?: ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPoliciesLimitDetail[];
|
|
3220
|
+
matchMode?: string;
|
|
3221
|
+
name?: string;
|
|
3222
|
+
policyId?: string;
|
|
3223
|
+
priority?: number;
|
|
3224
|
+
status?: string;
|
|
3225
|
+
whitelist?: string[];
|
|
3226
|
+
static names(): {
|
|
3227
|
+
[key: string]: string;
|
|
3228
|
+
};
|
|
3229
|
+
static types(): {
|
|
3230
|
+
[key: string]: any;
|
|
3231
|
+
};
|
|
3232
|
+
constructor(map?: {
|
|
3233
|
+
[key: string]: any;
|
|
3234
|
+
});
|
|
3235
|
+
}
|
|
3236
|
+
export declare class ListRegistrationPoliciesForUserGroupResponseBodyUserGroups extends $tea.Model {
|
|
3237
|
+
policies?: ListRegistrationPoliciesForUserGroupResponseBodyUserGroupsPolicies[];
|
|
3238
|
+
userGroupId?: string;
|
|
3239
|
+
static names(): {
|
|
3240
|
+
[key: string]: string;
|
|
3241
|
+
};
|
|
3242
|
+
static types(): {
|
|
3243
|
+
[key: string]: any;
|
|
3244
|
+
};
|
|
3245
|
+
constructor(map?: {
|
|
3246
|
+
[key: string]: any;
|
|
3247
|
+
});
|
|
3248
|
+
}
|
|
3249
|
+
export declare class ListSoftwareForUserDeviceResponseBodySoftware extends $tea.Model {
|
|
3250
|
+
inc?: string;
|
|
3251
|
+
installTime?: string;
|
|
3252
|
+
name?: string;
|
|
3253
|
+
versions?: string[];
|
|
3254
|
+
static names(): {
|
|
3255
|
+
[key: string]: string;
|
|
3256
|
+
};
|
|
3257
|
+
static types(): {
|
|
3258
|
+
[key: string]: any;
|
|
3259
|
+
};
|
|
3260
|
+
constructor(map?: {
|
|
3261
|
+
[key: string]: any;
|
|
3262
|
+
});
|
|
3263
|
+
}
|
|
2271
3264
|
export declare class ListTagsForPrivateAccessApplicationResponseBodyApplicationsTags extends $tea.Model {
|
|
2272
3265
|
createTime?: string;
|
|
2273
3266
|
description?: string;
|
|
@@ -2326,6 +3319,42 @@ export declare class ListTagsForPrivateAccessPolicyResponseBodyPolices extends $
|
|
|
2326
3319
|
[key: string]: any;
|
|
2327
3320
|
});
|
|
2328
3321
|
}
|
|
3322
|
+
export declare class ListUserDevicesResponseBodyDevices extends $tea.Model {
|
|
3323
|
+
appStatus?: string;
|
|
3324
|
+
appVersion?: string;
|
|
3325
|
+
CPU?: string;
|
|
3326
|
+
createTime?: string;
|
|
3327
|
+
department?: string;
|
|
3328
|
+
deviceBelong?: string;
|
|
3329
|
+
deviceModel?: string;
|
|
3330
|
+
deviceStatus?: string;
|
|
3331
|
+
deviceTag?: string;
|
|
3332
|
+
deviceType?: string;
|
|
3333
|
+
deviceVersion?: string;
|
|
3334
|
+
disk?: string;
|
|
3335
|
+
dlpStatus?: string;
|
|
3336
|
+
hostname?: string;
|
|
3337
|
+
iaStatus?: string;
|
|
3338
|
+
innerIP?: string;
|
|
3339
|
+
mac?: string;
|
|
3340
|
+
memory?: string;
|
|
3341
|
+
nacStatus?: string;
|
|
3342
|
+
paStatus?: string;
|
|
3343
|
+
saseUserId?: string;
|
|
3344
|
+
sharingStatus?: boolean;
|
|
3345
|
+
srcIP?: string;
|
|
3346
|
+
updateTime?: string;
|
|
3347
|
+
username?: string;
|
|
3348
|
+
static names(): {
|
|
3349
|
+
[key: string]: string;
|
|
3350
|
+
};
|
|
3351
|
+
static types(): {
|
|
3352
|
+
[key: string]: any;
|
|
3353
|
+
};
|
|
3354
|
+
constructor(map?: {
|
|
3355
|
+
[key: string]: any;
|
|
3356
|
+
});
|
|
3357
|
+
}
|
|
2329
3358
|
export declare class ListUserGroupsResponseBodyUserGroupsAttributes extends $tea.Model {
|
|
2330
3359
|
idpId?: number;
|
|
2331
3360
|
relation?: string;
|
|
@@ -2401,6 +3430,73 @@ export declare class ListUserGroupsForPrivateAccessPolicyResponseBodyPolices ext
|
|
|
2401
3430
|
[key: string]: any;
|
|
2402
3431
|
});
|
|
2403
3432
|
}
|
|
3433
|
+
export declare class ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroupsAttributes extends $tea.Model {
|
|
3434
|
+
idpId?: number;
|
|
3435
|
+
relation?: string;
|
|
3436
|
+
userGroupType?: string;
|
|
3437
|
+
value?: string;
|
|
3438
|
+
static names(): {
|
|
3439
|
+
[key: string]: string;
|
|
3440
|
+
};
|
|
3441
|
+
static types(): {
|
|
3442
|
+
[key: string]: any;
|
|
3443
|
+
};
|
|
3444
|
+
constructor(map?: {
|
|
3445
|
+
[key: string]: any;
|
|
3446
|
+
});
|
|
3447
|
+
}
|
|
3448
|
+
export declare class ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroups extends $tea.Model {
|
|
3449
|
+
attributes?: ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroupsAttributes[];
|
|
3450
|
+
createTime?: string;
|
|
3451
|
+
description?: string;
|
|
3452
|
+
name?: string;
|
|
3453
|
+
userGroupId?: string;
|
|
3454
|
+
static names(): {
|
|
3455
|
+
[key: string]: string;
|
|
3456
|
+
};
|
|
3457
|
+
static types(): {
|
|
3458
|
+
[key: string]: any;
|
|
3459
|
+
};
|
|
3460
|
+
constructor(map?: {
|
|
3461
|
+
[key: string]: any;
|
|
3462
|
+
});
|
|
3463
|
+
}
|
|
3464
|
+
export declare class ListUserGroupsForRegistrationPolicyResponseBodyPolicies extends $tea.Model {
|
|
3465
|
+
policyId?: string;
|
|
3466
|
+
userGroups?: ListUserGroupsForRegistrationPolicyResponseBodyPoliciesUserGroups[];
|
|
3467
|
+
static names(): {
|
|
3468
|
+
[key: string]: string;
|
|
3469
|
+
};
|
|
3470
|
+
static types(): {
|
|
3471
|
+
[key: string]: any;
|
|
3472
|
+
};
|
|
3473
|
+
constructor(map?: {
|
|
3474
|
+
[key: string]: any;
|
|
3475
|
+
});
|
|
3476
|
+
}
|
|
3477
|
+
export declare class UpdateExcessiveDeviceRegistrationApplicationsStatusResponseBodyApplications extends $tea.Model {
|
|
3478
|
+
applicationId?: string;
|
|
3479
|
+
createTime?: string;
|
|
3480
|
+
department?: string;
|
|
3481
|
+
description?: string;
|
|
3482
|
+
deviceTag?: string;
|
|
3483
|
+
deviceType?: string;
|
|
3484
|
+
hostname?: string;
|
|
3485
|
+
isUsed?: boolean;
|
|
3486
|
+
mac?: string;
|
|
3487
|
+
saseUserId?: string;
|
|
3488
|
+
status?: string;
|
|
3489
|
+
username?: string;
|
|
3490
|
+
static names(): {
|
|
3491
|
+
[key: string]: string;
|
|
3492
|
+
};
|
|
3493
|
+
static types(): {
|
|
3494
|
+
[key: string]: any;
|
|
3495
|
+
};
|
|
3496
|
+
constructor(map?: {
|
|
3497
|
+
[key: string]: any;
|
|
3498
|
+
});
|
|
3499
|
+
}
|
|
2404
3500
|
export declare class UpdatePrivateAccessApplicationRequestPortRanges extends $tea.Model {
|
|
2405
3501
|
begin?: number;
|
|
2406
3502
|
end?: number;
|
|
@@ -2429,6 +3525,155 @@ export declare class UpdatePrivateAccessPolicyRequestCustomUserAttributes extend
|
|
|
2429
3525
|
[key: string]: any;
|
|
2430
3526
|
});
|
|
2431
3527
|
}
|
|
3528
|
+
export declare class UpdateRegistrationPolicyRequestCompanyLimitCount extends $tea.Model {
|
|
3529
|
+
all?: number;
|
|
3530
|
+
mobile?: number;
|
|
3531
|
+
PC?: number;
|
|
3532
|
+
static names(): {
|
|
3533
|
+
[key: string]: string;
|
|
3534
|
+
};
|
|
3535
|
+
static types(): {
|
|
3536
|
+
[key: string]: any;
|
|
3537
|
+
};
|
|
3538
|
+
constructor(map?: {
|
|
3539
|
+
[key: string]: any;
|
|
3540
|
+
});
|
|
3541
|
+
}
|
|
3542
|
+
export declare class UpdateRegistrationPolicyRequestPersonalLimitCount extends $tea.Model {
|
|
3543
|
+
all?: number;
|
|
3544
|
+
mobile?: number;
|
|
3545
|
+
PC?: number;
|
|
3546
|
+
static names(): {
|
|
3547
|
+
[key: string]: string;
|
|
3548
|
+
};
|
|
3549
|
+
static types(): {
|
|
3550
|
+
[key: string]: any;
|
|
3551
|
+
};
|
|
3552
|
+
constructor(map?: {
|
|
3553
|
+
[key: string]: any;
|
|
3554
|
+
});
|
|
3555
|
+
}
|
|
3556
|
+
export declare class UpdateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount extends $tea.Model {
|
|
3557
|
+
all?: number;
|
|
3558
|
+
mobile?: number;
|
|
3559
|
+
PC?: number;
|
|
3560
|
+
static names(): {
|
|
3561
|
+
[key: string]: string;
|
|
3562
|
+
};
|
|
3563
|
+
static types(): {
|
|
3564
|
+
[key: string]: any;
|
|
3565
|
+
};
|
|
3566
|
+
constructor(map?: {
|
|
3567
|
+
[key: string]: any;
|
|
3568
|
+
});
|
|
3569
|
+
}
|
|
3570
|
+
export declare class UpdateRegistrationPolicyResponseBodyPolicyLimitDetail extends $tea.Model {
|
|
3571
|
+
deviceBelong?: string;
|
|
3572
|
+
limitCount?: UpdateRegistrationPolicyResponseBodyPolicyLimitDetailLimitCount;
|
|
3573
|
+
limitType?: string;
|
|
3574
|
+
static names(): {
|
|
3575
|
+
[key: string]: string;
|
|
3576
|
+
};
|
|
3577
|
+
static types(): {
|
|
3578
|
+
[key: string]: any;
|
|
3579
|
+
};
|
|
3580
|
+
constructor(map?: {
|
|
3581
|
+
[key: string]: any;
|
|
3582
|
+
});
|
|
3583
|
+
}
|
|
3584
|
+
export declare class UpdateRegistrationPolicyResponseBodyPolicy extends $tea.Model {
|
|
3585
|
+
createTime?: string;
|
|
3586
|
+
description?: string;
|
|
3587
|
+
limitDetail?: UpdateRegistrationPolicyResponseBodyPolicyLimitDetail[];
|
|
3588
|
+
matchMode?: string;
|
|
3589
|
+
name?: string;
|
|
3590
|
+
policyId?: string;
|
|
3591
|
+
priority?: string;
|
|
3592
|
+
status?: string;
|
|
3593
|
+
userGroupIds?: string[];
|
|
3594
|
+
whitelist?: string[];
|
|
3595
|
+
static names(): {
|
|
3596
|
+
[key: string]: string;
|
|
3597
|
+
};
|
|
3598
|
+
static types(): {
|
|
3599
|
+
[key: string]: any;
|
|
3600
|
+
};
|
|
3601
|
+
constructor(map?: {
|
|
3602
|
+
[key: string]: any;
|
|
3603
|
+
});
|
|
3604
|
+
}
|
|
3605
|
+
export declare class UpdateUserDevicesSharingStatusResponseBodyDevices extends $tea.Model {
|
|
3606
|
+
appStatus?: string;
|
|
3607
|
+
appVersion?: string;
|
|
3608
|
+
CPU?: string;
|
|
3609
|
+
createTime?: string;
|
|
3610
|
+
department?: string;
|
|
3611
|
+
deviceBelong?: string;
|
|
3612
|
+
deviceModel?: string;
|
|
3613
|
+
deviceStatus?: string;
|
|
3614
|
+
deviceTag?: string;
|
|
3615
|
+
deviceType?: string;
|
|
3616
|
+
deviceVersion?: string;
|
|
3617
|
+
disk?: string;
|
|
3618
|
+
dlpStatus?: string;
|
|
3619
|
+
hostname?: string;
|
|
3620
|
+
iaStatus?: string;
|
|
3621
|
+
innerIP?: string;
|
|
3622
|
+
mac?: string;
|
|
3623
|
+
memory?: string;
|
|
3624
|
+
nacStatus?: string;
|
|
3625
|
+
paStatus?: string;
|
|
3626
|
+
saseUserId?: string;
|
|
3627
|
+
sharingStatus?: boolean;
|
|
3628
|
+
srcIP?: string;
|
|
3629
|
+
updateTime?: string;
|
|
3630
|
+
username?: string;
|
|
3631
|
+
static names(): {
|
|
3632
|
+
[key: string]: string;
|
|
3633
|
+
};
|
|
3634
|
+
static types(): {
|
|
3635
|
+
[key: string]: any;
|
|
3636
|
+
};
|
|
3637
|
+
constructor(map?: {
|
|
3638
|
+
[key: string]: any;
|
|
3639
|
+
});
|
|
3640
|
+
}
|
|
3641
|
+
export declare class UpdateUserDevicesStatusResponseBodyDevices extends $tea.Model {
|
|
3642
|
+
appStatus?: string;
|
|
3643
|
+
appVersion?: string;
|
|
3644
|
+
CPU?: string;
|
|
3645
|
+
createTime?: string;
|
|
3646
|
+
department?: string;
|
|
3647
|
+
deviceBelong?: string;
|
|
3648
|
+
deviceModel?: string;
|
|
3649
|
+
deviceStatus?: string;
|
|
3650
|
+
deviceTag?: string;
|
|
3651
|
+
deviceType?: string;
|
|
3652
|
+
deviceVersion?: string;
|
|
3653
|
+
disk?: string;
|
|
3654
|
+
dlpStatus?: string;
|
|
3655
|
+
hostname?: string;
|
|
3656
|
+
iaStatus?: string;
|
|
3657
|
+
innerIP?: string;
|
|
3658
|
+
mac?: string;
|
|
3659
|
+
memory?: string;
|
|
3660
|
+
nacStatus?: string;
|
|
3661
|
+
paStatus?: string;
|
|
3662
|
+
saseUserId?: string;
|
|
3663
|
+
sharingStatus?: boolean;
|
|
3664
|
+
srcIP?: string;
|
|
3665
|
+
updateTime?: string;
|
|
3666
|
+
username?: string;
|
|
3667
|
+
static names(): {
|
|
3668
|
+
[key: string]: string;
|
|
3669
|
+
};
|
|
3670
|
+
static types(): {
|
|
3671
|
+
[key: string]: any;
|
|
3672
|
+
};
|
|
3673
|
+
constructor(map?: {
|
|
3674
|
+
[key: string]: any;
|
|
3675
|
+
});
|
|
3676
|
+
}
|
|
2432
3677
|
export declare class UpdateUserGroupRequestAttributes extends $tea.Model {
|
|
2433
3678
|
idpId?: number;
|
|
2434
3679
|
relation?: string;
|
|
@@ -2459,6 +3704,8 @@ export default class Client extends OpenApi {
|
|
|
2459
3704
|
createPrivateAccessPolicy(request: CreatePrivateAccessPolicyRequest): Promise<CreatePrivateAccessPolicyResponse>;
|
|
2460
3705
|
createPrivateAccessTagWithOptions(request: CreatePrivateAccessTagRequest, runtime: $Util.RuntimeOptions): Promise<CreatePrivateAccessTagResponse>;
|
|
2461
3706
|
createPrivateAccessTag(request: CreatePrivateAccessTagRequest): Promise<CreatePrivateAccessTagResponse>;
|
|
3707
|
+
createRegistrationPolicyWithOptions(tmpReq: CreateRegistrationPolicyRequest, runtime: $Util.RuntimeOptions): Promise<CreateRegistrationPolicyResponse>;
|
|
3708
|
+
createRegistrationPolicy(request: CreateRegistrationPolicyRequest): Promise<CreateRegistrationPolicyResponse>;
|
|
2462
3709
|
createUserGroupWithOptions(request: CreateUserGroupRequest, runtime: $Util.RuntimeOptions): Promise<CreateUserGroupResponse>;
|
|
2463
3710
|
createUserGroup(request: CreateUserGroupRequest): Promise<CreateUserGroupResponse>;
|
|
2464
3711
|
deleteDynamicRouteWithOptions(request: DeleteDynamicRouteRequest, runtime: $Util.RuntimeOptions): Promise<DeleteDynamicRouteResponse>;
|
|
@@ -2469,6 +3716,8 @@ export default class Client extends OpenApi {
|
|
|
2469
3716
|
deletePrivateAccessPolicy(request: DeletePrivateAccessPolicyRequest): Promise<DeletePrivateAccessPolicyResponse>;
|
|
2470
3717
|
deletePrivateAccessTagWithOptions(request: DeletePrivateAccessTagRequest, runtime: $Util.RuntimeOptions): Promise<DeletePrivateAccessTagResponse>;
|
|
2471
3718
|
deletePrivateAccessTag(request: DeletePrivateAccessTagRequest): Promise<DeletePrivateAccessTagResponse>;
|
|
3719
|
+
deleteRegistrationPoliciesWithOptions(request: DeleteRegistrationPoliciesRequest, runtime: $Util.RuntimeOptions): Promise<DeleteRegistrationPoliciesResponse>;
|
|
3720
|
+
deleteRegistrationPolicies(request: DeleteRegistrationPoliciesRequest): Promise<DeleteRegistrationPoliciesResponse>;
|
|
2472
3721
|
deleteUserGroupWithOptions(request: DeleteUserGroupRequest, runtime: $Util.RuntimeOptions): Promise<DeleteUserGroupResponse>;
|
|
2473
3722
|
deleteUserGroup(request: DeleteUserGroupRequest): Promise<DeleteUserGroupResponse>;
|
|
2474
3723
|
detachApplication2ConnectorWithOptions(tmpReq: DetachApplication2ConnectorRequest, runtime: $Util.RuntimeOptions): Promise<DetachApplication2ConnectorResponse>;
|
|
@@ -2479,6 +3728,10 @@ export default class Client extends OpenApi {
|
|
|
2479
3728
|
getPrivateAccessApplication(request: GetPrivateAccessApplicationRequest): Promise<GetPrivateAccessApplicationResponse>;
|
|
2480
3729
|
getPrivateAccessPolicyWithOptions(request: GetPrivateAccessPolicyRequest, runtime: $Util.RuntimeOptions): Promise<GetPrivateAccessPolicyResponse>;
|
|
2481
3730
|
getPrivateAccessPolicy(request: GetPrivateAccessPolicyRequest): Promise<GetPrivateAccessPolicyResponse>;
|
|
3731
|
+
getRegistrationPolicyWithOptions(request: GetRegistrationPolicyRequest, runtime: $Util.RuntimeOptions): Promise<GetRegistrationPolicyResponse>;
|
|
3732
|
+
getRegistrationPolicy(request: GetRegistrationPolicyRequest): Promise<GetRegistrationPolicyResponse>;
|
|
3733
|
+
getUserDeviceWithOptions(request: GetUserDeviceRequest, runtime: $Util.RuntimeOptions): Promise<GetUserDeviceResponse>;
|
|
3734
|
+
getUserDevice(request: GetUserDeviceRequest): Promise<GetUserDeviceResponse>;
|
|
2482
3735
|
getUserGroupWithOptions(request: GetUserGroupRequest, runtime: $Util.RuntimeOptions): Promise<GetUserGroupResponse>;
|
|
2483
3736
|
getUserGroup(request: GetUserGroupRequest): Promise<GetUserGroupResponse>;
|
|
2484
3737
|
listApplicationsForPrivateAccessPolicyWithOptions(request: ListApplicationsForPrivateAccessPolicyRequest, runtime: $Util.RuntimeOptions): Promise<ListApplicationsForPrivateAccessPolicyResponse>;
|
|
@@ -2491,6 +3744,8 @@ export default class Client extends OpenApi {
|
|
|
2491
3744
|
listDynamicRouteRegions(): Promise<ListDynamicRouteRegionsResponse>;
|
|
2492
3745
|
listDynamicRoutesWithOptions(request: ListDynamicRoutesRequest, runtime: $Util.RuntimeOptions): Promise<ListDynamicRoutesResponse>;
|
|
2493
3746
|
listDynamicRoutes(request: ListDynamicRoutesRequest): Promise<ListDynamicRoutesResponse>;
|
|
3747
|
+
listExcessiveDeviceRegistrationApplicationsWithOptions(request: ListExcessiveDeviceRegistrationApplicationsRequest, runtime: $Util.RuntimeOptions): Promise<ListExcessiveDeviceRegistrationApplicationsResponse>;
|
|
3748
|
+
listExcessiveDeviceRegistrationApplications(request: ListExcessiveDeviceRegistrationApplicationsRequest): Promise<ListExcessiveDeviceRegistrationApplicationsResponse>;
|
|
2494
3749
|
listPolicesForPrivateAccessApplicationWithOptions(request: ListPolicesForPrivateAccessApplicationRequest, runtime: $Util.RuntimeOptions): Promise<ListPolicesForPrivateAccessApplicationResponse>;
|
|
2495
3750
|
listPolicesForPrivateAccessApplication(request: ListPolicesForPrivateAccessApplicationRequest): Promise<ListPolicesForPrivateAccessApplicationResponse>;
|
|
2496
3751
|
listPolicesForPrivateAccessTagWithOptions(request: ListPolicesForPrivateAccessTagRequest, runtime: $Util.RuntimeOptions): Promise<ListPolicesForPrivateAccessTagResponse>;
|
|
@@ -2507,20 +3762,38 @@ export default class Client extends OpenApi {
|
|
|
2507
3762
|
listPrivateAccessTags(request: ListPrivateAccessTagsRequest): Promise<ListPrivateAccessTagsResponse>;
|
|
2508
3763
|
listPrivateAccessTagsForDynamicRouteWithOptions(request: ListPrivateAccessTagsForDynamicRouteRequest, runtime: $Util.RuntimeOptions): Promise<ListPrivateAccessTagsForDynamicRouteResponse>;
|
|
2509
3764
|
listPrivateAccessTagsForDynamicRoute(request: ListPrivateAccessTagsForDynamicRouteRequest): Promise<ListPrivateAccessTagsForDynamicRouteResponse>;
|
|
3765
|
+
listRegistrationPoliciesWithOptions(request: ListRegistrationPoliciesRequest, runtime: $Util.RuntimeOptions): Promise<ListRegistrationPoliciesResponse>;
|
|
3766
|
+
listRegistrationPolicies(request: ListRegistrationPoliciesRequest): Promise<ListRegistrationPoliciesResponse>;
|
|
3767
|
+
listRegistrationPoliciesForUserGroupWithOptions(request: ListRegistrationPoliciesForUserGroupRequest, runtime: $Util.RuntimeOptions): Promise<ListRegistrationPoliciesForUserGroupResponse>;
|
|
3768
|
+
listRegistrationPoliciesForUserGroup(request: ListRegistrationPoliciesForUserGroupRequest): Promise<ListRegistrationPoliciesForUserGroupResponse>;
|
|
3769
|
+
listSoftwareForUserDeviceWithOptions(request: ListSoftwareForUserDeviceRequest, runtime: $Util.RuntimeOptions): Promise<ListSoftwareForUserDeviceResponse>;
|
|
3770
|
+
listSoftwareForUserDevice(request: ListSoftwareForUserDeviceRequest): Promise<ListSoftwareForUserDeviceResponse>;
|
|
2510
3771
|
listTagsForPrivateAccessApplicationWithOptions(request: ListTagsForPrivateAccessApplicationRequest, runtime: $Util.RuntimeOptions): Promise<ListTagsForPrivateAccessApplicationResponse>;
|
|
2511
3772
|
listTagsForPrivateAccessApplication(request: ListTagsForPrivateAccessApplicationRequest): Promise<ListTagsForPrivateAccessApplicationResponse>;
|
|
2512
3773
|
listTagsForPrivateAccessPolicyWithOptions(request: ListTagsForPrivateAccessPolicyRequest, runtime: $Util.RuntimeOptions): Promise<ListTagsForPrivateAccessPolicyResponse>;
|
|
2513
3774
|
listTagsForPrivateAccessPolicy(request: ListTagsForPrivateAccessPolicyRequest): Promise<ListTagsForPrivateAccessPolicyResponse>;
|
|
3775
|
+
listUserDevicesWithOptions(request: ListUserDevicesRequest, runtime: $Util.RuntimeOptions): Promise<ListUserDevicesResponse>;
|
|
3776
|
+
listUserDevices(request: ListUserDevicesRequest): Promise<ListUserDevicesResponse>;
|
|
2514
3777
|
listUserGroupsWithOptions(request: ListUserGroupsRequest, runtime: $Util.RuntimeOptions): Promise<ListUserGroupsResponse>;
|
|
2515
3778
|
listUserGroups(request: ListUserGroupsRequest): Promise<ListUserGroupsResponse>;
|
|
2516
3779
|
listUserGroupsForPrivateAccessPolicyWithOptions(request: ListUserGroupsForPrivateAccessPolicyRequest, runtime: $Util.RuntimeOptions): Promise<ListUserGroupsForPrivateAccessPolicyResponse>;
|
|
2517
3780
|
listUserGroupsForPrivateAccessPolicy(request: ListUserGroupsForPrivateAccessPolicyRequest): Promise<ListUserGroupsForPrivateAccessPolicyResponse>;
|
|
3781
|
+
listUserGroupsForRegistrationPolicyWithOptions(request: ListUserGroupsForRegistrationPolicyRequest, runtime: $Util.RuntimeOptions): Promise<ListUserGroupsForRegistrationPolicyResponse>;
|
|
3782
|
+
listUserGroupsForRegistrationPolicy(request: ListUserGroupsForRegistrationPolicyRequest): Promise<ListUserGroupsForRegistrationPolicyResponse>;
|
|
2518
3783
|
updateDynamicRouteWithOptions(request: UpdateDynamicRouteRequest, runtime: $Util.RuntimeOptions): Promise<UpdateDynamicRouteResponse>;
|
|
2519
3784
|
updateDynamicRoute(request: UpdateDynamicRouteRequest): Promise<UpdateDynamicRouteResponse>;
|
|
3785
|
+
updateExcessiveDeviceRegistrationApplicationsStatusWithOptions(request: UpdateExcessiveDeviceRegistrationApplicationsStatusRequest, runtime: $Util.RuntimeOptions): Promise<UpdateExcessiveDeviceRegistrationApplicationsStatusResponse>;
|
|
3786
|
+
updateExcessiveDeviceRegistrationApplicationsStatus(request: UpdateExcessiveDeviceRegistrationApplicationsStatusRequest): Promise<UpdateExcessiveDeviceRegistrationApplicationsStatusResponse>;
|
|
2520
3787
|
updatePrivateAccessApplicationWithOptions(request: UpdatePrivateAccessApplicationRequest, runtime: $Util.RuntimeOptions): Promise<UpdatePrivateAccessApplicationResponse>;
|
|
2521
3788
|
updatePrivateAccessApplication(request: UpdatePrivateAccessApplicationRequest): Promise<UpdatePrivateAccessApplicationResponse>;
|
|
2522
3789
|
updatePrivateAccessPolicyWithOptions(request: UpdatePrivateAccessPolicyRequest, runtime: $Util.RuntimeOptions): Promise<UpdatePrivateAccessPolicyResponse>;
|
|
2523
3790
|
updatePrivateAccessPolicy(request: UpdatePrivateAccessPolicyRequest): Promise<UpdatePrivateAccessPolicyResponse>;
|
|
3791
|
+
updateRegistrationPolicyWithOptions(tmpReq: UpdateRegistrationPolicyRequest, runtime: $Util.RuntimeOptions): Promise<UpdateRegistrationPolicyResponse>;
|
|
3792
|
+
updateRegistrationPolicy(request: UpdateRegistrationPolicyRequest): Promise<UpdateRegistrationPolicyResponse>;
|
|
3793
|
+
updateUserDevicesSharingStatusWithOptions(request: UpdateUserDevicesSharingStatusRequest, runtime: $Util.RuntimeOptions): Promise<UpdateUserDevicesSharingStatusResponse>;
|
|
3794
|
+
updateUserDevicesSharingStatus(request: UpdateUserDevicesSharingStatusRequest): Promise<UpdateUserDevicesSharingStatusResponse>;
|
|
3795
|
+
updateUserDevicesStatusWithOptions(request: UpdateUserDevicesStatusRequest, runtime: $Util.RuntimeOptions): Promise<UpdateUserDevicesStatusResponse>;
|
|
3796
|
+
updateUserDevicesStatus(request: UpdateUserDevicesStatusRequest): Promise<UpdateUserDevicesStatusResponse>;
|
|
2524
3797
|
updateUserGroupWithOptions(request: UpdateUserGroupRequest, runtime: $Util.RuntimeOptions): Promise<UpdateUserGroupResponse>;
|
|
2525
3798
|
updateUserGroup(request: UpdateUserGroupRequest): Promise<UpdateUserGroupResponse>;
|
|
2526
3799
|
}
|