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