alibabacloud-eiam20211201 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl
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.
- alibabacloud_eiam20211201/__init__.py +1 -1
- alibabacloud_eiam20211201/client.py +1194 -126
- alibabacloud_eiam20211201/models.py +1746 -47
- {alibabacloud_eiam20211201-2.3.0.dist-info → alibabacloud_eiam20211201-2.4.0.dist-info}/METADATA +1 -1
- alibabacloud_eiam20211201-2.4.0.dist-info/RECORD +8 -0
- alibabacloud_eiam20211201-2.3.0.dist-info/RECORD +0 -8
- {alibabacloud_eiam20211201-2.3.0.dist-info → alibabacloud_eiam20211201-2.4.0.dist-info}/LICENSE +0 -0
- {alibabacloud_eiam20211201-2.3.0.dist-info → alibabacloud_eiam20211201-2.4.0.dist-info}/WHEEL +0 -0
- {alibabacloud_eiam20211201-2.3.0.dist-info → alibabacloud_eiam20211201-2.4.0.dist-info}/top_level.txt +0 -0
|
@@ -149,6 +149,110 @@ class Client(OpenApiClient):
|
|
|
149
149
|
runtime = util_models.RuntimeOptions()
|
|
150
150
|
return await self.add_application_account_to_user_with_options_async(request, runtime)
|
|
151
151
|
|
|
152
|
+
def add_custom_privacy_policies_to_brand_with_options(
|
|
153
|
+
self,
|
|
154
|
+
request: eiam_20211201_models.AddCustomPrivacyPoliciesToBrandRequest,
|
|
155
|
+
runtime: util_models.RuntimeOptions,
|
|
156
|
+
) -> eiam_20211201_models.AddCustomPrivacyPoliciesToBrandResponse:
|
|
157
|
+
"""
|
|
158
|
+
@summary 添加条款到品牌
|
|
159
|
+
|
|
160
|
+
@param request: AddCustomPrivacyPoliciesToBrandRequest
|
|
161
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
162
|
+
@return: AddCustomPrivacyPoliciesToBrandResponse
|
|
163
|
+
"""
|
|
164
|
+
UtilClient.validate_model(request)
|
|
165
|
+
query = {}
|
|
166
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
167
|
+
query['BrandId'] = request.brand_id
|
|
168
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_ids):
|
|
169
|
+
query['CustomPrivacyPolicyIds'] = request.custom_privacy_policy_ids
|
|
170
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
171
|
+
query['InstanceId'] = request.instance_id
|
|
172
|
+
req = open_api_models.OpenApiRequest(
|
|
173
|
+
query=OpenApiUtilClient.query(query)
|
|
174
|
+
)
|
|
175
|
+
params = open_api_models.Params(
|
|
176
|
+
action='AddCustomPrivacyPoliciesToBrand',
|
|
177
|
+
version='2021-12-01',
|
|
178
|
+
protocol='HTTPS',
|
|
179
|
+
pathname='/',
|
|
180
|
+
method='POST',
|
|
181
|
+
auth_type='AK',
|
|
182
|
+
style='RPC',
|
|
183
|
+
req_body_type='formData',
|
|
184
|
+
body_type='json'
|
|
185
|
+
)
|
|
186
|
+
return TeaCore.from_map(
|
|
187
|
+
eiam_20211201_models.AddCustomPrivacyPoliciesToBrandResponse(),
|
|
188
|
+
self.call_api(params, req, runtime)
|
|
189
|
+
)
|
|
190
|
+
|
|
191
|
+
async def add_custom_privacy_policies_to_brand_with_options_async(
|
|
192
|
+
self,
|
|
193
|
+
request: eiam_20211201_models.AddCustomPrivacyPoliciesToBrandRequest,
|
|
194
|
+
runtime: util_models.RuntimeOptions,
|
|
195
|
+
) -> eiam_20211201_models.AddCustomPrivacyPoliciesToBrandResponse:
|
|
196
|
+
"""
|
|
197
|
+
@summary 添加条款到品牌
|
|
198
|
+
|
|
199
|
+
@param request: AddCustomPrivacyPoliciesToBrandRequest
|
|
200
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
201
|
+
@return: AddCustomPrivacyPoliciesToBrandResponse
|
|
202
|
+
"""
|
|
203
|
+
UtilClient.validate_model(request)
|
|
204
|
+
query = {}
|
|
205
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
206
|
+
query['BrandId'] = request.brand_id
|
|
207
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_ids):
|
|
208
|
+
query['CustomPrivacyPolicyIds'] = request.custom_privacy_policy_ids
|
|
209
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
210
|
+
query['InstanceId'] = request.instance_id
|
|
211
|
+
req = open_api_models.OpenApiRequest(
|
|
212
|
+
query=OpenApiUtilClient.query(query)
|
|
213
|
+
)
|
|
214
|
+
params = open_api_models.Params(
|
|
215
|
+
action='AddCustomPrivacyPoliciesToBrand',
|
|
216
|
+
version='2021-12-01',
|
|
217
|
+
protocol='HTTPS',
|
|
218
|
+
pathname='/',
|
|
219
|
+
method='POST',
|
|
220
|
+
auth_type='AK',
|
|
221
|
+
style='RPC',
|
|
222
|
+
req_body_type='formData',
|
|
223
|
+
body_type='json'
|
|
224
|
+
)
|
|
225
|
+
return TeaCore.from_map(
|
|
226
|
+
eiam_20211201_models.AddCustomPrivacyPoliciesToBrandResponse(),
|
|
227
|
+
await self.call_api_async(params, req, runtime)
|
|
228
|
+
)
|
|
229
|
+
|
|
230
|
+
def add_custom_privacy_policies_to_brand(
|
|
231
|
+
self,
|
|
232
|
+
request: eiam_20211201_models.AddCustomPrivacyPoliciesToBrandRequest,
|
|
233
|
+
) -> eiam_20211201_models.AddCustomPrivacyPoliciesToBrandResponse:
|
|
234
|
+
"""
|
|
235
|
+
@summary 添加条款到品牌
|
|
236
|
+
|
|
237
|
+
@param request: AddCustomPrivacyPoliciesToBrandRequest
|
|
238
|
+
@return: AddCustomPrivacyPoliciesToBrandResponse
|
|
239
|
+
"""
|
|
240
|
+
runtime = util_models.RuntimeOptions()
|
|
241
|
+
return self.add_custom_privacy_policies_to_brand_with_options(request, runtime)
|
|
242
|
+
|
|
243
|
+
async def add_custom_privacy_policies_to_brand_async(
|
|
244
|
+
self,
|
|
245
|
+
request: eiam_20211201_models.AddCustomPrivacyPoliciesToBrandRequest,
|
|
246
|
+
) -> eiam_20211201_models.AddCustomPrivacyPoliciesToBrandResponse:
|
|
247
|
+
"""
|
|
248
|
+
@summary 添加条款到品牌
|
|
249
|
+
|
|
250
|
+
@param request: AddCustomPrivacyPoliciesToBrandRequest
|
|
251
|
+
@return: AddCustomPrivacyPoliciesToBrandResponse
|
|
252
|
+
"""
|
|
253
|
+
runtime = util_models.RuntimeOptions()
|
|
254
|
+
return await self.add_custom_privacy_policies_to_brand_with_options_async(request, runtime)
|
|
255
|
+
|
|
152
256
|
def add_user_to_organizational_units_with_options(
|
|
153
257
|
self,
|
|
154
258
|
request: eiam_20211201_models.AddUserToOrganizationalUnitsRequest,
|
|
@@ -1373,6 +1477,126 @@ class Client(OpenApiClient):
|
|
|
1373
1477
|
runtime = util_models.RuntimeOptions()
|
|
1374
1478
|
return await self.create_conditional_access_policy_with_options_async(request, runtime)
|
|
1375
1479
|
|
|
1480
|
+
def create_custom_privacy_policy_with_options(
|
|
1481
|
+
self,
|
|
1482
|
+
request: eiam_20211201_models.CreateCustomPrivacyPolicyRequest,
|
|
1483
|
+
runtime: util_models.RuntimeOptions,
|
|
1484
|
+
) -> eiam_20211201_models.CreateCustomPrivacyPolicyResponse:
|
|
1485
|
+
"""
|
|
1486
|
+
@summary 创建自定义条款
|
|
1487
|
+
|
|
1488
|
+
@param request: CreateCustomPrivacyPolicyRequest
|
|
1489
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1490
|
+
@return: CreateCustomPrivacyPolicyResponse
|
|
1491
|
+
"""
|
|
1492
|
+
UtilClient.validate_model(request)
|
|
1493
|
+
query = {}
|
|
1494
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1495
|
+
query['ClientToken'] = request.client_token
|
|
1496
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_contents):
|
|
1497
|
+
query['CustomPrivacyPolicyContents'] = request.custom_privacy_policy_contents
|
|
1498
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name):
|
|
1499
|
+
query['CustomPrivacyPolicyName'] = request.custom_privacy_policy_name
|
|
1500
|
+
if not UtilClient.is_unset(request.default_language_code):
|
|
1501
|
+
query['DefaultLanguageCode'] = request.default_language_code
|
|
1502
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
1503
|
+
query['InstanceId'] = request.instance_id
|
|
1504
|
+
if not UtilClient.is_unset(request.status):
|
|
1505
|
+
query['Status'] = request.status
|
|
1506
|
+
if not UtilClient.is_unset(request.user_consent_type):
|
|
1507
|
+
query['UserConsentType'] = request.user_consent_type
|
|
1508
|
+
req = open_api_models.OpenApiRequest(
|
|
1509
|
+
query=OpenApiUtilClient.query(query)
|
|
1510
|
+
)
|
|
1511
|
+
params = open_api_models.Params(
|
|
1512
|
+
action='CreateCustomPrivacyPolicy',
|
|
1513
|
+
version='2021-12-01',
|
|
1514
|
+
protocol='HTTPS',
|
|
1515
|
+
pathname='/',
|
|
1516
|
+
method='POST',
|
|
1517
|
+
auth_type='AK',
|
|
1518
|
+
style='RPC',
|
|
1519
|
+
req_body_type='formData',
|
|
1520
|
+
body_type='json'
|
|
1521
|
+
)
|
|
1522
|
+
return TeaCore.from_map(
|
|
1523
|
+
eiam_20211201_models.CreateCustomPrivacyPolicyResponse(),
|
|
1524
|
+
self.call_api(params, req, runtime)
|
|
1525
|
+
)
|
|
1526
|
+
|
|
1527
|
+
async def create_custom_privacy_policy_with_options_async(
|
|
1528
|
+
self,
|
|
1529
|
+
request: eiam_20211201_models.CreateCustomPrivacyPolicyRequest,
|
|
1530
|
+
runtime: util_models.RuntimeOptions,
|
|
1531
|
+
) -> eiam_20211201_models.CreateCustomPrivacyPolicyResponse:
|
|
1532
|
+
"""
|
|
1533
|
+
@summary 创建自定义条款
|
|
1534
|
+
|
|
1535
|
+
@param request: CreateCustomPrivacyPolicyRequest
|
|
1536
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1537
|
+
@return: CreateCustomPrivacyPolicyResponse
|
|
1538
|
+
"""
|
|
1539
|
+
UtilClient.validate_model(request)
|
|
1540
|
+
query = {}
|
|
1541
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1542
|
+
query['ClientToken'] = request.client_token
|
|
1543
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_contents):
|
|
1544
|
+
query['CustomPrivacyPolicyContents'] = request.custom_privacy_policy_contents
|
|
1545
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name):
|
|
1546
|
+
query['CustomPrivacyPolicyName'] = request.custom_privacy_policy_name
|
|
1547
|
+
if not UtilClient.is_unset(request.default_language_code):
|
|
1548
|
+
query['DefaultLanguageCode'] = request.default_language_code
|
|
1549
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
1550
|
+
query['InstanceId'] = request.instance_id
|
|
1551
|
+
if not UtilClient.is_unset(request.status):
|
|
1552
|
+
query['Status'] = request.status
|
|
1553
|
+
if not UtilClient.is_unset(request.user_consent_type):
|
|
1554
|
+
query['UserConsentType'] = request.user_consent_type
|
|
1555
|
+
req = open_api_models.OpenApiRequest(
|
|
1556
|
+
query=OpenApiUtilClient.query(query)
|
|
1557
|
+
)
|
|
1558
|
+
params = open_api_models.Params(
|
|
1559
|
+
action='CreateCustomPrivacyPolicy',
|
|
1560
|
+
version='2021-12-01',
|
|
1561
|
+
protocol='HTTPS',
|
|
1562
|
+
pathname='/',
|
|
1563
|
+
method='POST',
|
|
1564
|
+
auth_type='AK',
|
|
1565
|
+
style='RPC',
|
|
1566
|
+
req_body_type='formData',
|
|
1567
|
+
body_type='json'
|
|
1568
|
+
)
|
|
1569
|
+
return TeaCore.from_map(
|
|
1570
|
+
eiam_20211201_models.CreateCustomPrivacyPolicyResponse(),
|
|
1571
|
+
await self.call_api_async(params, req, runtime)
|
|
1572
|
+
)
|
|
1573
|
+
|
|
1574
|
+
def create_custom_privacy_policy(
|
|
1575
|
+
self,
|
|
1576
|
+
request: eiam_20211201_models.CreateCustomPrivacyPolicyRequest,
|
|
1577
|
+
) -> eiam_20211201_models.CreateCustomPrivacyPolicyResponse:
|
|
1578
|
+
"""
|
|
1579
|
+
@summary 创建自定义条款
|
|
1580
|
+
|
|
1581
|
+
@param request: CreateCustomPrivacyPolicyRequest
|
|
1582
|
+
@return: CreateCustomPrivacyPolicyResponse
|
|
1583
|
+
"""
|
|
1584
|
+
runtime = util_models.RuntimeOptions()
|
|
1585
|
+
return self.create_custom_privacy_policy_with_options(request, runtime)
|
|
1586
|
+
|
|
1587
|
+
async def create_custom_privacy_policy_async(
|
|
1588
|
+
self,
|
|
1589
|
+
request: eiam_20211201_models.CreateCustomPrivacyPolicyRequest,
|
|
1590
|
+
) -> eiam_20211201_models.CreateCustomPrivacyPolicyResponse:
|
|
1591
|
+
"""
|
|
1592
|
+
@summary 创建自定义条款
|
|
1593
|
+
|
|
1594
|
+
@param request: CreateCustomPrivacyPolicyRequest
|
|
1595
|
+
@return: CreateCustomPrivacyPolicyResponse
|
|
1596
|
+
"""
|
|
1597
|
+
runtime = util_models.RuntimeOptions()
|
|
1598
|
+
return await self.create_custom_privacy_policy_with_options_async(request, runtime)
|
|
1599
|
+
|
|
1376
1600
|
def create_domain_with_options(
|
|
1377
1601
|
self,
|
|
1378
1602
|
request: eiam_20211201_models.CreateDomainRequest,
|
|
@@ -3201,6 +3425,106 @@ class Client(OpenApiClient):
|
|
|
3201
3425
|
runtime = util_models.RuntimeOptions()
|
|
3202
3426
|
return await self.delete_conditional_access_policy_with_options_async(request, runtime)
|
|
3203
3427
|
|
|
3428
|
+
def delete_custom_privacy_policy_with_options(
|
|
3429
|
+
self,
|
|
3430
|
+
request: eiam_20211201_models.DeleteCustomPrivacyPolicyRequest,
|
|
3431
|
+
runtime: util_models.RuntimeOptions,
|
|
3432
|
+
) -> eiam_20211201_models.DeleteCustomPrivacyPolicyResponse:
|
|
3433
|
+
"""
|
|
3434
|
+
@summary 删除自定义条款
|
|
3435
|
+
|
|
3436
|
+
@param request: DeleteCustomPrivacyPolicyRequest
|
|
3437
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3438
|
+
@return: DeleteCustomPrivacyPolicyResponse
|
|
3439
|
+
"""
|
|
3440
|
+
UtilClient.validate_model(request)
|
|
3441
|
+
query = {}
|
|
3442
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
3443
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
3444
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
3445
|
+
query['InstanceId'] = request.instance_id
|
|
3446
|
+
req = open_api_models.OpenApiRequest(
|
|
3447
|
+
query=OpenApiUtilClient.query(query)
|
|
3448
|
+
)
|
|
3449
|
+
params = open_api_models.Params(
|
|
3450
|
+
action='DeleteCustomPrivacyPolicy',
|
|
3451
|
+
version='2021-12-01',
|
|
3452
|
+
protocol='HTTPS',
|
|
3453
|
+
pathname='/',
|
|
3454
|
+
method='POST',
|
|
3455
|
+
auth_type='AK',
|
|
3456
|
+
style='RPC',
|
|
3457
|
+
req_body_type='formData',
|
|
3458
|
+
body_type='json'
|
|
3459
|
+
)
|
|
3460
|
+
return TeaCore.from_map(
|
|
3461
|
+
eiam_20211201_models.DeleteCustomPrivacyPolicyResponse(),
|
|
3462
|
+
self.call_api(params, req, runtime)
|
|
3463
|
+
)
|
|
3464
|
+
|
|
3465
|
+
async def delete_custom_privacy_policy_with_options_async(
|
|
3466
|
+
self,
|
|
3467
|
+
request: eiam_20211201_models.DeleteCustomPrivacyPolicyRequest,
|
|
3468
|
+
runtime: util_models.RuntimeOptions,
|
|
3469
|
+
) -> eiam_20211201_models.DeleteCustomPrivacyPolicyResponse:
|
|
3470
|
+
"""
|
|
3471
|
+
@summary 删除自定义条款
|
|
3472
|
+
|
|
3473
|
+
@param request: DeleteCustomPrivacyPolicyRequest
|
|
3474
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3475
|
+
@return: DeleteCustomPrivacyPolicyResponse
|
|
3476
|
+
"""
|
|
3477
|
+
UtilClient.validate_model(request)
|
|
3478
|
+
query = {}
|
|
3479
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
3480
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
3481
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
3482
|
+
query['InstanceId'] = request.instance_id
|
|
3483
|
+
req = open_api_models.OpenApiRequest(
|
|
3484
|
+
query=OpenApiUtilClient.query(query)
|
|
3485
|
+
)
|
|
3486
|
+
params = open_api_models.Params(
|
|
3487
|
+
action='DeleteCustomPrivacyPolicy',
|
|
3488
|
+
version='2021-12-01',
|
|
3489
|
+
protocol='HTTPS',
|
|
3490
|
+
pathname='/',
|
|
3491
|
+
method='POST',
|
|
3492
|
+
auth_type='AK',
|
|
3493
|
+
style='RPC',
|
|
3494
|
+
req_body_type='formData',
|
|
3495
|
+
body_type='json'
|
|
3496
|
+
)
|
|
3497
|
+
return TeaCore.from_map(
|
|
3498
|
+
eiam_20211201_models.DeleteCustomPrivacyPolicyResponse(),
|
|
3499
|
+
await self.call_api_async(params, req, runtime)
|
|
3500
|
+
)
|
|
3501
|
+
|
|
3502
|
+
def delete_custom_privacy_policy(
|
|
3503
|
+
self,
|
|
3504
|
+
request: eiam_20211201_models.DeleteCustomPrivacyPolicyRequest,
|
|
3505
|
+
) -> eiam_20211201_models.DeleteCustomPrivacyPolicyResponse:
|
|
3506
|
+
"""
|
|
3507
|
+
@summary 删除自定义条款
|
|
3508
|
+
|
|
3509
|
+
@param request: DeleteCustomPrivacyPolicyRequest
|
|
3510
|
+
@return: DeleteCustomPrivacyPolicyResponse
|
|
3511
|
+
"""
|
|
3512
|
+
runtime = util_models.RuntimeOptions()
|
|
3513
|
+
return self.delete_custom_privacy_policy_with_options(request, runtime)
|
|
3514
|
+
|
|
3515
|
+
async def delete_custom_privacy_policy_async(
|
|
3516
|
+
self,
|
|
3517
|
+
request: eiam_20211201_models.DeleteCustomPrivacyPolicyRequest,
|
|
3518
|
+
) -> eiam_20211201_models.DeleteCustomPrivacyPolicyResponse:
|
|
3519
|
+
"""
|
|
3520
|
+
@summary 删除自定义条款
|
|
3521
|
+
|
|
3522
|
+
@param request: DeleteCustomPrivacyPolicyRequest
|
|
3523
|
+
@return: DeleteCustomPrivacyPolicyResponse
|
|
3524
|
+
"""
|
|
3525
|
+
runtime = util_models.RuntimeOptions()
|
|
3526
|
+
return await self.delete_custom_privacy_policy_with_options_async(request, runtime)
|
|
3527
|
+
|
|
3204
3528
|
def delete_domain_with_options(
|
|
3205
3529
|
self,
|
|
3206
3530
|
request: eiam_20211201_models.DeleteDomainRequest,
|
|
@@ -5237,31 +5561,29 @@ class Client(OpenApiClient):
|
|
|
5237
5561
|
runtime = util_models.RuntimeOptions()
|
|
5238
5562
|
return await self.disable_conditional_access_policy_with_options_async(request, runtime)
|
|
5239
5563
|
|
|
5240
|
-
def
|
|
5564
|
+
def disable_custom_privacy_policy_with_options(
|
|
5241
5565
|
self,
|
|
5242
|
-
request: eiam_20211201_models.
|
|
5566
|
+
request: eiam_20211201_models.DisableCustomPrivacyPolicyRequest,
|
|
5243
5567
|
runtime: util_models.RuntimeOptions,
|
|
5244
|
-
) -> eiam_20211201_models.
|
|
5568
|
+
) -> eiam_20211201_models.DisableCustomPrivacyPolicyResponse:
|
|
5245
5569
|
"""
|
|
5246
|
-
@summary
|
|
5570
|
+
@summary 禁用自定义条款
|
|
5247
5571
|
|
|
5248
|
-
@param request:
|
|
5572
|
+
@param request: DisableCustomPrivacyPolicyRequest
|
|
5249
5573
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5250
|
-
@return:
|
|
5574
|
+
@return: DisableCustomPrivacyPolicyResponse
|
|
5251
5575
|
"""
|
|
5252
5576
|
UtilClient.validate_model(request)
|
|
5253
5577
|
query = {}
|
|
5254
|
-
if not UtilClient.is_unset(request.
|
|
5255
|
-
query['
|
|
5256
|
-
if not UtilClient.is_unset(request.domain_proxy_token_id):
|
|
5257
|
-
query['DomainProxyTokenId'] = request.domain_proxy_token_id
|
|
5578
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
5579
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
5258
5580
|
if not UtilClient.is_unset(request.instance_id):
|
|
5259
5581
|
query['InstanceId'] = request.instance_id
|
|
5260
5582
|
req = open_api_models.OpenApiRequest(
|
|
5261
5583
|
query=OpenApiUtilClient.query(query)
|
|
5262
5584
|
)
|
|
5263
5585
|
params = open_api_models.Params(
|
|
5264
|
-
action='
|
|
5586
|
+
action='DisableCustomPrivacyPolicy',
|
|
5265
5587
|
version='2021-12-01',
|
|
5266
5588
|
protocol='HTTPS',
|
|
5267
5589
|
pathname='/',
|
|
@@ -5272,35 +5594,33 @@ class Client(OpenApiClient):
|
|
|
5272
5594
|
body_type='json'
|
|
5273
5595
|
)
|
|
5274
5596
|
return TeaCore.from_map(
|
|
5275
|
-
eiam_20211201_models.
|
|
5597
|
+
eiam_20211201_models.DisableCustomPrivacyPolicyResponse(),
|
|
5276
5598
|
self.call_api(params, req, runtime)
|
|
5277
5599
|
)
|
|
5278
5600
|
|
|
5279
|
-
async def
|
|
5601
|
+
async def disable_custom_privacy_policy_with_options_async(
|
|
5280
5602
|
self,
|
|
5281
|
-
request: eiam_20211201_models.
|
|
5603
|
+
request: eiam_20211201_models.DisableCustomPrivacyPolicyRequest,
|
|
5282
5604
|
runtime: util_models.RuntimeOptions,
|
|
5283
|
-
) -> eiam_20211201_models.
|
|
5605
|
+
) -> eiam_20211201_models.DisableCustomPrivacyPolicyResponse:
|
|
5284
5606
|
"""
|
|
5285
|
-
@summary
|
|
5607
|
+
@summary 禁用自定义条款
|
|
5286
5608
|
|
|
5287
|
-
@param request:
|
|
5609
|
+
@param request: DisableCustomPrivacyPolicyRequest
|
|
5288
5610
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5289
|
-
@return:
|
|
5611
|
+
@return: DisableCustomPrivacyPolicyResponse
|
|
5290
5612
|
"""
|
|
5291
5613
|
UtilClient.validate_model(request)
|
|
5292
5614
|
query = {}
|
|
5293
|
-
if not UtilClient.is_unset(request.
|
|
5294
|
-
query['
|
|
5295
|
-
if not UtilClient.is_unset(request.domain_proxy_token_id):
|
|
5296
|
-
query['DomainProxyTokenId'] = request.domain_proxy_token_id
|
|
5615
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
5616
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
5297
5617
|
if not UtilClient.is_unset(request.instance_id):
|
|
5298
5618
|
query['InstanceId'] = request.instance_id
|
|
5299
5619
|
req = open_api_models.OpenApiRequest(
|
|
5300
5620
|
query=OpenApiUtilClient.query(query)
|
|
5301
5621
|
)
|
|
5302
5622
|
params = open_api_models.Params(
|
|
5303
|
-
action='
|
|
5623
|
+
action='DisableCustomPrivacyPolicy',
|
|
5304
5624
|
version='2021-12-01',
|
|
5305
5625
|
protocol='HTTPS',
|
|
5306
5626
|
pathname='/',
|
|
@@ -5311,43 +5631,147 @@ class Client(OpenApiClient):
|
|
|
5311
5631
|
body_type='json'
|
|
5312
5632
|
)
|
|
5313
5633
|
return TeaCore.from_map(
|
|
5314
|
-
eiam_20211201_models.
|
|
5634
|
+
eiam_20211201_models.DisableCustomPrivacyPolicyResponse(),
|
|
5315
5635
|
await self.call_api_async(params, req, runtime)
|
|
5316
5636
|
)
|
|
5317
5637
|
|
|
5318
|
-
def
|
|
5638
|
+
def disable_custom_privacy_policy(
|
|
5319
5639
|
self,
|
|
5320
|
-
request: eiam_20211201_models.
|
|
5321
|
-
) -> eiam_20211201_models.
|
|
5640
|
+
request: eiam_20211201_models.DisableCustomPrivacyPolicyRequest,
|
|
5641
|
+
) -> eiam_20211201_models.DisableCustomPrivacyPolicyResponse:
|
|
5322
5642
|
"""
|
|
5323
|
-
@summary
|
|
5643
|
+
@summary 禁用自定义条款
|
|
5324
5644
|
|
|
5325
|
-
@param request:
|
|
5326
|
-
@return:
|
|
5645
|
+
@param request: DisableCustomPrivacyPolicyRequest
|
|
5646
|
+
@return: DisableCustomPrivacyPolicyResponse
|
|
5327
5647
|
"""
|
|
5328
5648
|
runtime = util_models.RuntimeOptions()
|
|
5329
|
-
return self.
|
|
5649
|
+
return self.disable_custom_privacy_policy_with_options(request, runtime)
|
|
5330
5650
|
|
|
5331
|
-
async def
|
|
5651
|
+
async def disable_custom_privacy_policy_async(
|
|
5332
5652
|
self,
|
|
5333
|
-
request: eiam_20211201_models.
|
|
5334
|
-
) -> eiam_20211201_models.
|
|
5653
|
+
request: eiam_20211201_models.DisableCustomPrivacyPolicyRequest,
|
|
5654
|
+
) -> eiam_20211201_models.DisableCustomPrivacyPolicyResponse:
|
|
5335
5655
|
"""
|
|
5336
|
-
@summary
|
|
5656
|
+
@summary 禁用自定义条款
|
|
5337
5657
|
|
|
5338
|
-
@param request:
|
|
5339
|
-
@return:
|
|
5658
|
+
@param request: DisableCustomPrivacyPolicyRequest
|
|
5659
|
+
@return: DisableCustomPrivacyPolicyResponse
|
|
5340
5660
|
"""
|
|
5341
5661
|
runtime = util_models.RuntimeOptions()
|
|
5342
|
-
return await self.
|
|
5662
|
+
return await self.disable_custom_privacy_policy_with_options_async(request, runtime)
|
|
5343
5663
|
|
|
5344
|
-
def
|
|
5664
|
+
def disable_domain_proxy_token_with_options(
|
|
5345
5665
|
self,
|
|
5346
|
-
request: eiam_20211201_models.
|
|
5666
|
+
request: eiam_20211201_models.DisableDomainProxyTokenRequest,
|
|
5347
5667
|
runtime: util_models.RuntimeOptions,
|
|
5348
|
-
) -> eiam_20211201_models.
|
|
5668
|
+
) -> eiam_20211201_models.DisableDomainProxyTokenResponse:
|
|
5349
5669
|
"""
|
|
5350
|
-
@summary
|
|
5670
|
+
@summary Disables a proxy token for a domain name of an Employee Identity and Access Management (EIAM) instance. After the proxy token is disabled, the domain name may not be used as expected.
|
|
5671
|
+
|
|
5672
|
+
@param request: DisableDomainProxyTokenRequest
|
|
5673
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
5674
|
+
@return: DisableDomainProxyTokenResponse
|
|
5675
|
+
"""
|
|
5676
|
+
UtilClient.validate_model(request)
|
|
5677
|
+
query = {}
|
|
5678
|
+
if not UtilClient.is_unset(request.domain_id):
|
|
5679
|
+
query['DomainId'] = request.domain_id
|
|
5680
|
+
if not UtilClient.is_unset(request.domain_proxy_token_id):
|
|
5681
|
+
query['DomainProxyTokenId'] = request.domain_proxy_token_id
|
|
5682
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
5683
|
+
query['InstanceId'] = request.instance_id
|
|
5684
|
+
req = open_api_models.OpenApiRequest(
|
|
5685
|
+
query=OpenApiUtilClient.query(query)
|
|
5686
|
+
)
|
|
5687
|
+
params = open_api_models.Params(
|
|
5688
|
+
action='DisableDomainProxyToken',
|
|
5689
|
+
version='2021-12-01',
|
|
5690
|
+
protocol='HTTPS',
|
|
5691
|
+
pathname='/',
|
|
5692
|
+
method='POST',
|
|
5693
|
+
auth_type='AK',
|
|
5694
|
+
style='RPC',
|
|
5695
|
+
req_body_type='formData',
|
|
5696
|
+
body_type='json'
|
|
5697
|
+
)
|
|
5698
|
+
return TeaCore.from_map(
|
|
5699
|
+
eiam_20211201_models.DisableDomainProxyTokenResponse(),
|
|
5700
|
+
self.call_api(params, req, runtime)
|
|
5701
|
+
)
|
|
5702
|
+
|
|
5703
|
+
async def disable_domain_proxy_token_with_options_async(
|
|
5704
|
+
self,
|
|
5705
|
+
request: eiam_20211201_models.DisableDomainProxyTokenRequest,
|
|
5706
|
+
runtime: util_models.RuntimeOptions,
|
|
5707
|
+
) -> eiam_20211201_models.DisableDomainProxyTokenResponse:
|
|
5708
|
+
"""
|
|
5709
|
+
@summary Disables a proxy token for a domain name of an Employee Identity and Access Management (EIAM) instance. After the proxy token is disabled, the domain name may not be used as expected.
|
|
5710
|
+
|
|
5711
|
+
@param request: DisableDomainProxyTokenRequest
|
|
5712
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
5713
|
+
@return: DisableDomainProxyTokenResponse
|
|
5714
|
+
"""
|
|
5715
|
+
UtilClient.validate_model(request)
|
|
5716
|
+
query = {}
|
|
5717
|
+
if not UtilClient.is_unset(request.domain_id):
|
|
5718
|
+
query['DomainId'] = request.domain_id
|
|
5719
|
+
if not UtilClient.is_unset(request.domain_proxy_token_id):
|
|
5720
|
+
query['DomainProxyTokenId'] = request.domain_proxy_token_id
|
|
5721
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
5722
|
+
query['InstanceId'] = request.instance_id
|
|
5723
|
+
req = open_api_models.OpenApiRequest(
|
|
5724
|
+
query=OpenApiUtilClient.query(query)
|
|
5725
|
+
)
|
|
5726
|
+
params = open_api_models.Params(
|
|
5727
|
+
action='DisableDomainProxyToken',
|
|
5728
|
+
version='2021-12-01',
|
|
5729
|
+
protocol='HTTPS',
|
|
5730
|
+
pathname='/',
|
|
5731
|
+
method='POST',
|
|
5732
|
+
auth_type='AK',
|
|
5733
|
+
style='RPC',
|
|
5734
|
+
req_body_type='formData',
|
|
5735
|
+
body_type='json'
|
|
5736
|
+
)
|
|
5737
|
+
return TeaCore.from_map(
|
|
5738
|
+
eiam_20211201_models.DisableDomainProxyTokenResponse(),
|
|
5739
|
+
await self.call_api_async(params, req, runtime)
|
|
5740
|
+
)
|
|
5741
|
+
|
|
5742
|
+
def disable_domain_proxy_token(
|
|
5743
|
+
self,
|
|
5744
|
+
request: eiam_20211201_models.DisableDomainProxyTokenRequest,
|
|
5745
|
+
) -> eiam_20211201_models.DisableDomainProxyTokenResponse:
|
|
5746
|
+
"""
|
|
5747
|
+
@summary Disables a proxy token for a domain name of an Employee Identity and Access Management (EIAM) instance. After the proxy token is disabled, the domain name may not be used as expected.
|
|
5748
|
+
|
|
5749
|
+
@param request: DisableDomainProxyTokenRequest
|
|
5750
|
+
@return: DisableDomainProxyTokenResponse
|
|
5751
|
+
"""
|
|
5752
|
+
runtime = util_models.RuntimeOptions()
|
|
5753
|
+
return self.disable_domain_proxy_token_with_options(request, runtime)
|
|
5754
|
+
|
|
5755
|
+
async def disable_domain_proxy_token_async(
|
|
5756
|
+
self,
|
|
5757
|
+
request: eiam_20211201_models.DisableDomainProxyTokenRequest,
|
|
5758
|
+
) -> eiam_20211201_models.DisableDomainProxyTokenResponse:
|
|
5759
|
+
"""
|
|
5760
|
+
@summary Disables a proxy token for a domain name of an Employee Identity and Access Management (EIAM) instance. After the proxy token is disabled, the domain name may not be used as expected.
|
|
5761
|
+
|
|
5762
|
+
@param request: DisableDomainProxyTokenRequest
|
|
5763
|
+
@return: DisableDomainProxyTokenResponse
|
|
5764
|
+
"""
|
|
5765
|
+
runtime = util_models.RuntimeOptions()
|
|
5766
|
+
return await self.disable_domain_proxy_token_with_options_async(request, runtime)
|
|
5767
|
+
|
|
5768
|
+
def disable_federated_credential_provider_with_options(
|
|
5769
|
+
self,
|
|
5770
|
+
request: eiam_20211201_models.DisableFederatedCredentialProviderRequest,
|
|
5771
|
+
runtime: util_models.RuntimeOptions,
|
|
5772
|
+
) -> eiam_20211201_models.DisableFederatedCredentialProviderResponse:
|
|
5773
|
+
"""
|
|
5774
|
+
@summary 禁用联邦凭证提供方
|
|
5351
5775
|
|
|
5352
5776
|
@param request: DisableFederatedCredentialProviderRequest
|
|
5353
5777
|
@param runtime: runtime options for this request RuntimeOptions
|
|
@@ -6757,6 +7181,106 @@ class Client(OpenApiClient):
|
|
|
6757
7181
|
runtime = util_models.RuntimeOptions()
|
|
6758
7182
|
return await self.enable_conditional_access_policy_with_options_async(request, runtime)
|
|
6759
7183
|
|
|
7184
|
+
def enable_custom_privacy_policy_with_options(
|
|
7185
|
+
self,
|
|
7186
|
+
request: eiam_20211201_models.EnableCustomPrivacyPolicyRequest,
|
|
7187
|
+
runtime: util_models.RuntimeOptions,
|
|
7188
|
+
) -> eiam_20211201_models.EnableCustomPrivacyPolicyResponse:
|
|
7189
|
+
"""
|
|
7190
|
+
@summary 启用自定义条款
|
|
7191
|
+
|
|
7192
|
+
@param request: EnableCustomPrivacyPolicyRequest
|
|
7193
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
7194
|
+
@return: EnableCustomPrivacyPolicyResponse
|
|
7195
|
+
"""
|
|
7196
|
+
UtilClient.validate_model(request)
|
|
7197
|
+
query = {}
|
|
7198
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
7199
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
7200
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
7201
|
+
query['InstanceId'] = request.instance_id
|
|
7202
|
+
req = open_api_models.OpenApiRequest(
|
|
7203
|
+
query=OpenApiUtilClient.query(query)
|
|
7204
|
+
)
|
|
7205
|
+
params = open_api_models.Params(
|
|
7206
|
+
action='EnableCustomPrivacyPolicy',
|
|
7207
|
+
version='2021-12-01',
|
|
7208
|
+
protocol='HTTPS',
|
|
7209
|
+
pathname='/',
|
|
7210
|
+
method='POST',
|
|
7211
|
+
auth_type='AK',
|
|
7212
|
+
style='RPC',
|
|
7213
|
+
req_body_type='formData',
|
|
7214
|
+
body_type='json'
|
|
7215
|
+
)
|
|
7216
|
+
return TeaCore.from_map(
|
|
7217
|
+
eiam_20211201_models.EnableCustomPrivacyPolicyResponse(),
|
|
7218
|
+
self.call_api(params, req, runtime)
|
|
7219
|
+
)
|
|
7220
|
+
|
|
7221
|
+
async def enable_custom_privacy_policy_with_options_async(
|
|
7222
|
+
self,
|
|
7223
|
+
request: eiam_20211201_models.EnableCustomPrivacyPolicyRequest,
|
|
7224
|
+
runtime: util_models.RuntimeOptions,
|
|
7225
|
+
) -> eiam_20211201_models.EnableCustomPrivacyPolicyResponse:
|
|
7226
|
+
"""
|
|
7227
|
+
@summary 启用自定义条款
|
|
7228
|
+
|
|
7229
|
+
@param request: EnableCustomPrivacyPolicyRequest
|
|
7230
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
7231
|
+
@return: EnableCustomPrivacyPolicyResponse
|
|
7232
|
+
"""
|
|
7233
|
+
UtilClient.validate_model(request)
|
|
7234
|
+
query = {}
|
|
7235
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
7236
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
7237
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
7238
|
+
query['InstanceId'] = request.instance_id
|
|
7239
|
+
req = open_api_models.OpenApiRequest(
|
|
7240
|
+
query=OpenApiUtilClient.query(query)
|
|
7241
|
+
)
|
|
7242
|
+
params = open_api_models.Params(
|
|
7243
|
+
action='EnableCustomPrivacyPolicy',
|
|
7244
|
+
version='2021-12-01',
|
|
7245
|
+
protocol='HTTPS',
|
|
7246
|
+
pathname='/',
|
|
7247
|
+
method='POST',
|
|
7248
|
+
auth_type='AK',
|
|
7249
|
+
style='RPC',
|
|
7250
|
+
req_body_type='formData',
|
|
7251
|
+
body_type='json'
|
|
7252
|
+
)
|
|
7253
|
+
return TeaCore.from_map(
|
|
7254
|
+
eiam_20211201_models.EnableCustomPrivacyPolicyResponse(),
|
|
7255
|
+
await self.call_api_async(params, req, runtime)
|
|
7256
|
+
)
|
|
7257
|
+
|
|
7258
|
+
def enable_custom_privacy_policy(
|
|
7259
|
+
self,
|
|
7260
|
+
request: eiam_20211201_models.EnableCustomPrivacyPolicyRequest,
|
|
7261
|
+
) -> eiam_20211201_models.EnableCustomPrivacyPolicyResponse:
|
|
7262
|
+
"""
|
|
7263
|
+
@summary 启用自定义条款
|
|
7264
|
+
|
|
7265
|
+
@param request: EnableCustomPrivacyPolicyRequest
|
|
7266
|
+
@return: EnableCustomPrivacyPolicyResponse
|
|
7267
|
+
"""
|
|
7268
|
+
runtime = util_models.RuntimeOptions()
|
|
7269
|
+
return self.enable_custom_privacy_policy_with_options(request, runtime)
|
|
7270
|
+
|
|
7271
|
+
async def enable_custom_privacy_policy_async(
|
|
7272
|
+
self,
|
|
7273
|
+
request: eiam_20211201_models.EnableCustomPrivacyPolicyRequest,
|
|
7274
|
+
) -> eiam_20211201_models.EnableCustomPrivacyPolicyResponse:
|
|
7275
|
+
"""
|
|
7276
|
+
@summary 启用自定义条款
|
|
7277
|
+
|
|
7278
|
+
@param request: EnableCustomPrivacyPolicyRequest
|
|
7279
|
+
@return: EnableCustomPrivacyPolicyResponse
|
|
7280
|
+
"""
|
|
7281
|
+
runtime = util_models.RuntimeOptions()
|
|
7282
|
+
return await self.enable_custom_privacy_policy_with_options_async(request, runtime)
|
|
7283
|
+
|
|
6760
7284
|
def enable_domain_proxy_token_with_options(
|
|
6761
7285
|
self,
|
|
6762
7286
|
request: eiam_20211201_models.EnableDomainProxyTokenRequest,
|
|
@@ -8265,6 +8789,106 @@ class Client(OpenApiClient):
|
|
|
8265
8789
|
runtime = util_models.RuntimeOptions()
|
|
8266
8790
|
return await self.get_conditional_access_policy_with_options_async(request, runtime)
|
|
8267
8791
|
|
|
8792
|
+
def get_custom_privacy_policy_with_options(
|
|
8793
|
+
self,
|
|
8794
|
+
request: eiam_20211201_models.GetCustomPrivacyPolicyRequest,
|
|
8795
|
+
runtime: util_models.RuntimeOptions,
|
|
8796
|
+
) -> eiam_20211201_models.GetCustomPrivacyPolicyResponse:
|
|
8797
|
+
"""
|
|
8798
|
+
@summary 获取自定义条款
|
|
8799
|
+
|
|
8800
|
+
@param request: GetCustomPrivacyPolicyRequest
|
|
8801
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
8802
|
+
@return: GetCustomPrivacyPolicyResponse
|
|
8803
|
+
"""
|
|
8804
|
+
UtilClient.validate_model(request)
|
|
8805
|
+
query = {}
|
|
8806
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
8807
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
8808
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
8809
|
+
query['InstanceId'] = request.instance_id
|
|
8810
|
+
req = open_api_models.OpenApiRequest(
|
|
8811
|
+
query=OpenApiUtilClient.query(query)
|
|
8812
|
+
)
|
|
8813
|
+
params = open_api_models.Params(
|
|
8814
|
+
action='GetCustomPrivacyPolicy',
|
|
8815
|
+
version='2021-12-01',
|
|
8816
|
+
protocol='HTTPS',
|
|
8817
|
+
pathname='/',
|
|
8818
|
+
method='POST',
|
|
8819
|
+
auth_type='AK',
|
|
8820
|
+
style='RPC',
|
|
8821
|
+
req_body_type='formData',
|
|
8822
|
+
body_type='json'
|
|
8823
|
+
)
|
|
8824
|
+
return TeaCore.from_map(
|
|
8825
|
+
eiam_20211201_models.GetCustomPrivacyPolicyResponse(),
|
|
8826
|
+
self.call_api(params, req, runtime)
|
|
8827
|
+
)
|
|
8828
|
+
|
|
8829
|
+
async def get_custom_privacy_policy_with_options_async(
|
|
8830
|
+
self,
|
|
8831
|
+
request: eiam_20211201_models.GetCustomPrivacyPolicyRequest,
|
|
8832
|
+
runtime: util_models.RuntimeOptions,
|
|
8833
|
+
) -> eiam_20211201_models.GetCustomPrivacyPolicyResponse:
|
|
8834
|
+
"""
|
|
8835
|
+
@summary 获取自定义条款
|
|
8836
|
+
|
|
8837
|
+
@param request: GetCustomPrivacyPolicyRequest
|
|
8838
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
8839
|
+
@return: GetCustomPrivacyPolicyResponse
|
|
8840
|
+
"""
|
|
8841
|
+
UtilClient.validate_model(request)
|
|
8842
|
+
query = {}
|
|
8843
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
8844
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
8845
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
8846
|
+
query['InstanceId'] = request.instance_id
|
|
8847
|
+
req = open_api_models.OpenApiRequest(
|
|
8848
|
+
query=OpenApiUtilClient.query(query)
|
|
8849
|
+
)
|
|
8850
|
+
params = open_api_models.Params(
|
|
8851
|
+
action='GetCustomPrivacyPolicy',
|
|
8852
|
+
version='2021-12-01',
|
|
8853
|
+
protocol='HTTPS',
|
|
8854
|
+
pathname='/',
|
|
8855
|
+
method='POST',
|
|
8856
|
+
auth_type='AK',
|
|
8857
|
+
style='RPC',
|
|
8858
|
+
req_body_type='formData',
|
|
8859
|
+
body_type='json'
|
|
8860
|
+
)
|
|
8861
|
+
return TeaCore.from_map(
|
|
8862
|
+
eiam_20211201_models.GetCustomPrivacyPolicyResponse(),
|
|
8863
|
+
await self.call_api_async(params, req, runtime)
|
|
8864
|
+
)
|
|
8865
|
+
|
|
8866
|
+
def get_custom_privacy_policy(
|
|
8867
|
+
self,
|
|
8868
|
+
request: eiam_20211201_models.GetCustomPrivacyPolicyRequest,
|
|
8869
|
+
) -> eiam_20211201_models.GetCustomPrivacyPolicyResponse:
|
|
8870
|
+
"""
|
|
8871
|
+
@summary 获取自定义条款
|
|
8872
|
+
|
|
8873
|
+
@param request: GetCustomPrivacyPolicyRequest
|
|
8874
|
+
@return: GetCustomPrivacyPolicyResponse
|
|
8875
|
+
"""
|
|
8876
|
+
runtime = util_models.RuntimeOptions()
|
|
8877
|
+
return self.get_custom_privacy_policy_with_options(request, runtime)
|
|
8878
|
+
|
|
8879
|
+
async def get_custom_privacy_policy_async(
|
|
8880
|
+
self,
|
|
8881
|
+
request: eiam_20211201_models.GetCustomPrivacyPolicyRequest,
|
|
8882
|
+
) -> eiam_20211201_models.GetCustomPrivacyPolicyResponse:
|
|
8883
|
+
"""
|
|
8884
|
+
@summary 获取自定义条款
|
|
8885
|
+
|
|
8886
|
+
@param request: GetCustomPrivacyPolicyRequest
|
|
8887
|
+
@return: GetCustomPrivacyPolicyResponse
|
|
8888
|
+
"""
|
|
8889
|
+
runtime = util_models.RuntimeOptions()
|
|
8890
|
+
return await self.get_custom_privacy_policy_with_options_async(request, runtime)
|
|
8891
|
+
|
|
8268
8892
|
def get_domain_with_options(
|
|
8269
8893
|
self,
|
|
8270
8894
|
request: eiam_20211201_models.GetDomainRequest,
|
|
@@ -11994,46 +12618,258 @@ class Client(OpenApiClient):
|
|
|
11994
12618
|
@return: ListConditionalAccessPoliciesForApplicationResponse
|
|
11995
12619
|
"""
|
|
11996
12620
|
runtime = util_models.RuntimeOptions()
|
|
11997
|
-
return self.list_conditional_access_policies_for_application_with_options(request, runtime)
|
|
12621
|
+
return self.list_conditional_access_policies_for_application_with_options(request, runtime)
|
|
12622
|
+
|
|
12623
|
+
async def list_conditional_access_policies_for_application_async(
|
|
12624
|
+
self,
|
|
12625
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForApplicationRequest,
|
|
12626
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForApplicationResponse:
|
|
12627
|
+
"""
|
|
12628
|
+
@summary 获取应用关联的条件访问策略列表
|
|
12629
|
+
|
|
12630
|
+
@param request: ListConditionalAccessPoliciesForApplicationRequest
|
|
12631
|
+
@return: ListConditionalAccessPoliciesForApplicationResponse
|
|
12632
|
+
"""
|
|
12633
|
+
runtime = util_models.RuntimeOptions()
|
|
12634
|
+
return await self.list_conditional_access_policies_for_application_with_options_async(request, runtime)
|
|
12635
|
+
|
|
12636
|
+
def list_conditional_access_policies_for_network_zone_with_options(
|
|
12637
|
+
self,
|
|
12638
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneRequest,
|
|
12639
|
+
runtime: util_models.RuntimeOptions,
|
|
12640
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneResponse:
|
|
12641
|
+
"""
|
|
12642
|
+
@summary List Conditional Access Policies Associated with Network Areas
|
|
12643
|
+
|
|
12644
|
+
@description List Conditional Access Policies Associated with Network Zones
|
|
12645
|
+
|
|
12646
|
+
@param request: ListConditionalAccessPoliciesForNetworkZoneRequest
|
|
12647
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
12648
|
+
@return: ListConditionalAccessPoliciesForNetworkZoneResponse
|
|
12649
|
+
"""
|
|
12650
|
+
UtilClient.validate_model(request)
|
|
12651
|
+
query = {}
|
|
12652
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
12653
|
+
query['InstanceId'] = request.instance_id
|
|
12654
|
+
if not UtilClient.is_unset(request.network_zone_id):
|
|
12655
|
+
query['NetworkZoneId'] = request.network_zone_id
|
|
12656
|
+
req = open_api_models.OpenApiRequest(
|
|
12657
|
+
query=OpenApiUtilClient.query(query)
|
|
12658
|
+
)
|
|
12659
|
+
params = open_api_models.Params(
|
|
12660
|
+
action='ListConditionalAccessPoliciesForNetworkZone',
|
|
12661
|
+
version='2021-12-01',
|
|
12662
|
+
protocol='HTTPS',
|
|
12663
|
+
pathname='/',
|
|
12664
|
+
method='POST',
|
|
12665
|
+
auth_type='AK',
|
|
12666
|
+
style='RPC',
|
|
12667
|
+
req_body_type='formData',
|
|
12668
|
+
body_type='json'
|
|
12669
|
+
)
|
|
12670
|
+
return TeaCore.from_map(
|
|
12671
|
+
eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneResponse(),
|
|
12672
|
+
self.call_api(params, req, runtime)
|
|
12673
|
+
)
|
|
12674
|
+
|
|
12675
|
+
async def list_conditional_access_policies_for_network_zone_with_options_async(
|
|
12676
|
+
self,
|
|
12677
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneRequest,
|
|
12678
|
+
runtime: util_models.RuntimeOptions,
|
|
12679
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneResponse:
|
|
12680
|
+
"""
|
|
12681
|
+
@summary List Conditional Access Policies Associated with Network Areas
|
|
12682
|
+
|
|
12683
|
+
@description List Conditional Access Policies Associated with Network Zones
|
|
12684
|
+
|
|
12685
|
+
@param request: ListConditionalAccessPoliciesForNetworkZoneRequest
|
|
12686
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
12687
|
+
@return: ListConditionalAccessPoliciesForNetworkZoneResponse
|
|
12688
|
+
"""
|
|
12689
|
+
UtilClient.validate_model(request)
|
|
12690
|
+
query = {}
|
|
12691
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
12692
|
+
query['InstanceId'] = request.instance_id
|
|
12693
|
+
if not UtilClient.is_unset(request.network_zone_id):
|
|
12694
|
+
query['NetworkZoneId'] = request.network_zone_id
|
|
12695
|
+
req = open_api_models.OpenApiRequest(
|
|
12696
|
+
query=OpenApiUtilClient.query(query)
|
|
12697
|
+
)
|
|
12698
|
+
params = open_api_models.Params(
|
|
12699
|
+
action='ListConditionalAccessPoliciesForNetworkZone',
|
|
12700
|
+
version='2021-12-01',
|
|
12701
|
+
protocol='HTTPS',
|
|
12702
|
+
pathname='/',
|
|
12703
|
+
method='POST',
|
|
12704
|
+
auth_type='AK',
|
|
12705
|
+
style='RPC',
|
|
12706
|
+
req_body_type='formData',
|
|
12707
|
+
body_type='json'
|
|
12708
|
+
)
|
|
12709
|
+
return TeaCore.from_map(
|
|
12710
|
+
eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneResponse(),
|
|
12711
|
+
await self.call_api_async(params, req, runtime)
|
|
12712
|
+
)
|
|
12713
|
+
|
|
12714
|
+
def list_conditional_access_policies_for_network_zone(
|
|
12715
|
+
self,
|
|
12716
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneRequest,
|
|
12717
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneResponse:
|
|
12718
|
+
"""
|
|
12719
|
+
@summary List Conditional Access Policies Associated with Network Areas
|
|
12720
|
+
|
|
12721
|
+
@description List Conditional Access Policies Associated with Network Zones
|
|
12722
|
+
|
|
12723
|
+
@param request: ListConditionalAccessPoliciesForNetworkZoneRequest
|
|
12724
|
+
@return: ListConditionalAccessPoliciesForNetworkZoneResponse
|
|
12725
|
+
"""
|
|
12726
|
+
runtime = util_models.RuntimeOptions()
|
|
12727
|
+
return self.list_conditional_access_policies_for_network_zone_with_options(request, runtime)
|
|
12728
|
+
|
|
12729
|
+
async def list_conditional_access_policies_for_network_zone_async(
|
|
12730
|
+
self,
|
|
12731
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneRequest,
|
|
12732
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForNetworkZoneResponse:
|
|
12733
|
+
"""
|
|
12734
|
+
@summary List Conditional Access Policies Associated with Network Areas
|
|
12735
|
+
|
|
12736
|
+
@description List Conditional Access Policies Associated with Network Zones
|
|
12737
|
+
|
|
12738
|
+
@param request: ListConditionalAccessPoliciesForNetworkZoneRequest
|
|
12739
|
+
@return: ListConditionalAccessPoliciesForNetworkZoneResponse
|
|
12740
|
+
"""
|
|
12741
|
+
runtime = util_models.RuntimeOptions()
|
|
12742
|
+
return await self.list_conditional_access_policies_for_network_zone_with_options_async(request, runtime)
|
|
12743
|
+
|
|
12744
|
+
def list_conditional_access_policies_for_user_with_options(
|
|
12745
|
+
self,
|
|
12746
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForUserRequest,
|
|
12747
|
+
runtime: util_models.RuntimeOptions,
|
|
12748
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForUserResponse:
|
|
12749
|
+
"""
|
|
12750
|
+
@summary 获取用户关联的条件访问策略列表
|
|
12751
|
+
|
|
12752
|
+
@param request: ListConditionalAccessPoliciesForUserRequest
|
|
12753
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
12754
|
+
@return: ListConditionalAccessPoliciesForUserResponse
|
|
12755
|
+
"""
|
|
12756
|
+
UtilClient.validate_model(request)
|
|
12757
|
+
query = {}
|
|
12758
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
12759
|
+
query['InstanceId'] = request.instance_id
|
|
12760
|
+
if not UtilClient.is_unset(request.user_id):
|
|
12761
|
+
query['UserId'] = request.user_id
|
|
12762
|
+
req = open_api_models.OpenApiRequest(
|
|
12763
|
+
query=OpenApiUtilClient.query(query)
|
|
12764
|
+
)
|
|
12765
|
+
params = open_api_models.Params(
|
|
12766
|
+
action='ListConditionalAccessPoliciesForUser',
|
|
12767
|
+
version='2021-12-01',
|
|
12768
|
+
protocol='HTTPS',
|
|
12769
|
+
pathname='/',
|
|
12770
|
+
method='POST',
|
|
12771
|
+
auth_type='AK',
|
|
12772
|
+
style='RPC',
|
|
12773
|
+
req_body_type='formData',
|
|
12774
|
+
body_type='json'
|
|
12775
|
+
)
|
|
12776
|
+
return TeaCore.from_map(
|
|
12777
|
+
eiam_20211201_models.ListConditionalAccessPoliciesForUserResponse(),
|
|
12778
|
+
self.call_api(params, req, runtime)
|
|
12779
|
+
)
|
|
12780
|
+
|
|
12781
|
+
async def list_conditional_access_policies_for_user_with_options_async(
|
|
12782
|
+
self,
|
|
12783
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForUserRequest,
|
|
12784
|
+
runtime: util_models.RuntimeOptions,
|
|
12785
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForUserResponse:
|
|
12786
|
+
"""
|
|
12787
|
+
@summary 获取用户关联的条件访问策略列表
|
|
12788
|
+
|
|
12789
|
+
@param request: ListConditionalAccessPoliciesForUserRequest
|
|
12790
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
12791
|
+
@return: ListConditionalAccessPoliciesForUserResponse
|
|
12792
|
+
"""
|
|
12793
|
+
UtilClient.validate_model(request)
|
|
12794
|
+
query = {}
|
|
12795
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
12796
|
+
query['InstanceId'] = request.instance_id
|
|
12797
|
+
if not UtilClient.is_unset(request.user_id):
|
|
12798
|
+
query['UserId'] = request.user_id
|
|
12799
|
+
req = open_api_models.OpenApiRequest(
|
|
12800
|
+
query=OpenApiUtilClient.query(query)
|
|
12801
|
+
)
|
|
12802
|
+
params = open_api_models.Params(
|
|
12803
|
+
action='ListConditionalAccessPoliciesForUser',
|
|
12804
|
+
version='2021-12-01',
|
|
12805
|
+
protocol='HTTPS',
|
|
12806
|
+
pathname='/',
|
|
12807
|
+
method='POST',
|
|
12808
|
+
auth_type='AK',
|
|
12809
|
+
style='RPC',
|
|
12810
|
+
req_body_type='formData',
|
|
12811
|
+
body_type='json'
|
|
12812
|
+
)
|
|
12813
|
+
return TeaCore.from_map(
|
|
12814
|
+
eiam_20211201_models.ListConditionalAccessPoliciesForUserResponse(),
|
|
12815
|
+
await self.call_api_async(params, req, runtime)
|
|
12816
|
+
)
|
|
12817
|
+
|
|
12818
|
+
def list_conditional_access_policies_for_user(
|
|
12819
|
+
self,
|
|
12820
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForUserRequest,
|
|
12821
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForUserResponse:
|
|
12822
|
+
"""
|
|
12823
|
+
@summary 获取用户关联的条件访问策略列表
|
|
12824
|
+
|
|
12825
|
+
@param request: ListConditionalAccessPoliciesForUserRequest
|
|
12826
|
+
@return: ListConditionalAccessPoliciesForUserResponse
|
|
12827
|
+
"""
|
|
12828
|
+
runtime = util_models.RuntimeOptions()
|
|
12829
|
+
return self.list_conditional_access_policies_for_user_with_options(request, runtime)
|
|
11998
12830
|
|
|
11999
|
-
async def
|
|
12831
|
+
async def list_conditional_access_policies_for_user_async(
|
|
12000
12832
|
self,
|
|
12001
|
-
request: eiam_20211201_models.
|
|
12002
|
-
) -> eiam_20211201_models.
|
|
12833
|
+
request: eiam_20211201_models.ListConditionalAccessPoliciesForUserRequest,
|
|
12834
|
+
) -> eiam_20211201_models.ListConditionalAccessPoliciesForUserResponse:
|
|
12003
12835
|
"""
|
|
12004
|
-
@summary
|
|
12836
|
+
@summary 获取用户关联的条件访问策略列表
|
|
12005
12837
|
|
|
12006
|
-
@param request:
|
|
12007
|
-
@return:
|
|
12838
|
+
@param request: ListConditionalAccessPoliciesForUserRequest
|
|
12839
|
+
@return: ListConditionalAccessPoliciesForUserResponse
|
|
12008
12840
|
"""
|
|
12009
12841
|
runtime = util_models.RuntimeOptions()
|
|
12010
|
-
return await self.
|
|
12842
|
+
return await self.list_conditional_access_policies_for_user_with_options_async(request, runtime)
|
|
12011
12843
|
|
|
12012
|
-
def
|
|
12844
|
+
def list_custom_privacy_policies_with_options(
|
|
12013
12845
|
self,
|
|
12014
|
-
request: eiam_20211201_models.
|
|
12846
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesRequest,
|
|
12015
12847
|
runtime: util_models.RuntimeOptions,
|
|
12016
|
-
) -> eiam_20211201_models.
|
|
12848
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesResponse:
|
|
12017
12849
|
"""
|
|
12018
|
-
@summary
|
|
12850
|
+
@summary 自定义条款列表查询。
|
|
12019
12851
|
|
|
12020
|
-
@
|
|
12021
|
-
|
|
12022
|
-
@param request: ListConditionalAccessPoliciesForNetworkZoneRequest
|
|
12852
|
+
@param request: ListCustomPrivacyPoliciesRequest
|
|
12023
12853
|
@param runtime: runtime options for this request RuntimeOptions
|
|
12024
|
-
@return:
|
|
12854
|
+
@return: ListCustomPrivacyPoliciesResponse
|
|
12025
12855
|
"""
|
|
12026
12856
|
UtilClient.validate_model(request)
|
|
12027
12857
|
query = {}
|
|
12858
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name_starts_with):
|
|
12859
|
+
query['CustomPrivacyPolicyNameStartsWith'] = request.custom_privacy_policy_name_starts_with
|
|
12028
12860
|
if not UtilClient.is_unset(request.instance_id):
|
|
12029
12861
|
query['InstanceId'] = request.instance_id
|
|
12030
|
-
if not UtilClient.is_unset(request.
|
|
12031
|
-
query['
|
|
12862
|
+
if not UtilClient.is_unset(request.max_results):
|
|
12863
|
+
query['MaxResults'] = request.max_results
|
|
12864
|
+
if not UtilClient.is_unset(request.next_token):
|
|
12865
|
+
query['NextToken'] = request.next_token
|
|
12866
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
12867
|
+
query['PreviousToken'] = request.previous_token
|
|
12032
12868
|
req = open_api_models.OpenApiRequest(
|
|
12033
12869
|
query=OpenApiUtilClient.query(query)
|
|
12034
12870
|
)
|
|
12035
12871
|
params = open_api_models.Params(
|
|
12036
|
-
action='
|
|
12872
|
+
action='ListCustomPrivacyPolicies',
|
|
12037
12873
|
version='2021-12-01',
|
|
12038
12874
|
protocol='HTTPS',
|
|
12039
12875
|
pathname='/',
|
|
@@ -12044,35 +12880,39 @@ class Client(OpenApiClient):
|
|
|
12044
12880
|
body_type='json'
|
|
12045
12881
|
)
|
|
12046
12882
|
return TeaCore.from_map(
|
|
12047
|
-
eiam_20211201_models.
|
|
12883
|
+
eiam_20211201_models.ListCustomPrivacyPoliciesResponse(),
|
|
12048
12884
|
self.call_api(params, req, runtime)
|
|
12049
12885
|
)
|
|
12050
12886
|
|
|
12051
|
-
async def
|
|
12887
|
+
async def list_custom_privacy_policies_with_options_async(
|
|
12052
12888
|
self,
|
|
12053
|
-
request: eiam_20211201_models.
|
|
12889
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesRequest,
|
|
12054
12890
|
runtime: util_models.RuntimeOptions,
|
|
12055
|
-
) -> eiam_20211201_models.
|
|
12891
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesResponse:
|
|
12056
12892
|
"""
|
|
12057
|
-
@summary
|
|
12058
|
-
|
|
12059
|
-
@description List Conditional Access Policies Associated with Network Zones
|
|
12893
|
+
@summary 自定义条款列表查询。
|
|
12060
12894
|
|
|
12061
|
-
@param request:
|
|
12895
|
+
@param request: ListCustomPrivacyPoliciesRequest
|
|
12062
12896
|
@param runtime: runtime options for this request RuntimeOptions
|
|
12063
|
-
@return:
|
|
12897
|
+
@return: ListCustomPrivacyPoliciesResponse
|
|
12064
12898
|
"""
|
|
12065
12899
|
UtilClient.validate_model(request)
|
|
12066
12900
|
query = {}
|
|
12901
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name_starts_with):
|
|
12902
|
+
query['CustomPrivacyPolicyNameStartsWith'] = request.custom_privacy_policy_name_starts_with
|
|
12067
12903
|
if not UtilClient.is_unset(request.instance_id):
|
|
12068
12904
|
query['InstanceId'] = request.instance_id
|
|
12069
|
-
if not UtilClient.is_unset(request.
|
|
12070
|
-
query['
|
|
12905
|
+
if not UtilClient.is_unset(request.max_results):
|
|
12906
|
+
query['MaxResults'] = request.max_results
|
|
12907
|
+
if not UtilClient.is_unset(request.next_token):
|
|
12908
|
+
query['NextToken'] = request.next_token
|
|
12909
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
12910
|
+
query['PreviousToken'] = request.previous_token
|
|
12071
12911
|
req = open_api_models.OpenApiRequest(
|
|
12072
12912
|
query=OpenApiUtilClient.query(query)
|
|
12073
12913
|
)
|
|
12074
12914
|
params = open_api_models.Params(
|
|
12075
|
-
action='
|
|
12915
|
+
action='ListCustomPrivacyPolicies',
|
|
12076
12916
|
version='2021-12-01',
|
|
12077
12917
|
protocol='HTTPS',
|
|
12078
12918
|
pathname='/',
|
|
@@ -12083,63 +12923,65 @@ class Client(OpenApiClient):
|
|
|
12083
12923
|
body_type='json'
|
|
12084
12924
|
)
|
|
12085
12925
|
return TeaCore.from_map(
|
|
12086
|
-
eiam_20211201_models.
|
|
12926
|
+
eiam_20211201_models.ListCustomPrivacyPoliciesResponse(),
|
|
12087
12927
|
await self.call_api_async(params, req, runtime)
|
|
12088
12928
|
)
|
|
12089
12929
|
|
|
12090
|
-
def
|
|
12930
|
+
def list_custom_privacy_policies(
|
|
12091
12931
|
self,
|
|
12092
|
-
request: eiam_20211201_models.
|
|
12093
|
-
) -> eiam_20211201_models.
|
|
12932
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesRequest,
|
|
12933
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesResponse:
|
|
12094
12934
|
"""
|
|
12095
|
-
@summary
|
|
12935
|
+
@summary 自定义条款列表查询。
|
|
12096
12936
|
|
|
12097
|
-
@
|
|
12098
|
-
|
|
12099
|
-
@param request: ListConditionalAccessPoliciesForNetworkZoneRequest
|
|
12100
|
-
@return: ListConditionalAccessPoliciesForNetworkZoneResponse
|
|
12937
|
+
@param request: ListCustomPrivacyPoliciesRequest
|
|
12938
|
+
@return: ListCustomPrivacyPoliciesResponse
|
|
12101
12939
|
"""
|
|
12102
12940
|
runtime = util_models.RuntimeOptions()
|
|
12103
|
-
return self.
|
|
12941
|
+
return self.list_custom_privacy_policies_with_options(request, runtime)
|
|
12104
12942
|
|
|
12105
|
-
async def
|
|
12943
|
+
async def list_custom_privacy_policies_async(
|
|
12106
12944
|
self,
|
|
12107
|
-
request: eiam_20211201_models.
|
|
12108
|
-
) -> eiam_20211201_models.
|
|
12945
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesRequest,
|
|
12946
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesResponse:
|
|
12109
12947
|
"""
|
|
12110
|
-
@summary
|
|
12111
|
-
|
|
12112
|
-
@description List Conditional Access Policies Associated with Network Zones
|
|
12948
|
+
@summary 自定义条款列表查询。
|
|
12113
12949
|
|
|
12114
|
-
@param request:
|
|
12115
|
-
@return:
|
|
12950
|
+
@param request: ListCustomPrivacyPoliciesRequest
|
|
12951
|
+
@return: ListCustomPrivacyPoliciesResponse
|
|
12116
12952
|
"""
|
|
12117
12953
|
runtime = util_models.RuntimeOptions()
|
|
12118
|
-
return await self.
|
|
12954
|
+
return await self.list_custom_privacy_policies_with_options_async(request, runtime)
|
|
12119
12955
|
|
|
12120
|
-
def
|
|
12956
|
+
def list_custom_privacy_policies_for_brand_with_options(
|
|
12121
12957
|
self,
|
|
12122
|
-
request: eiam_20211201_models.
|
|
12958
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesForBrandRequest,
|
|
12123
12959
|
runtime: util_models.RuntimeOptions,
|
|
12124
|
-
) -> eiam_20211201_models.
|
|
12960
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse:
|
|
12125
12961
|
"""
|
|
12126
|
-
@summary
|
|
12962
|
+
@summary 获取品牌关联资源的资源
|
|
12127
12963
|
|
|
12128
|
-
@param request:
|
|
12964
|
+
@param request: ListCustomPrivacyPoliciesForBrandRequest
|
|
12129
12965
|
@param runtime: runtime options for this request RuntimeOptions
|
|
12130
|
-
@return:
|
|
12966
|
+
@return: ListCustomPrivacyPoliciesForBrandResponse
|
|
12131
12967
|
"""
|
|
12132
12968
|
UtilClient.validate_model(request)
|
|
12133
12969
|
query = {}
|
|
12970
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
12971
|
+
query['BrandId'] = request.brand_id
|
|
12134
12972
|
if not UtilClient.is_unset(request.instance_id):
|
|
12135
12973
|
query['InstanceId'] = request.instance_id
|
|
12136
|
-
if not UtilClient.is_unset(request.
|
|
12137
|
-
query['
|
|
12974
|
+
if not UtilClient.is_unset(request.max_results):
|
|
12975
|
+
query['MaxResults'] = request.max_results
|
|
12976
|
+
if not UtilClient.is_unset(request.next_token):
|
|
12977
|
+
query['NextToken'] = request.next_token
|
|
12978
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
12979
|
+
query['PreviousToken'] = request.previous_token
|
|
12138
12980
|
req = open_api_models.OpenApiRequest(
|
|
12139
12981
|
query=OpenApiUtilClient.query(query)
|
|
12140
12982
|
)
|
|
12141
12983
|
params = open_api_models.Params(
|
|
12142
|
-
action='
|
|
12984
|
+
action='ListCustomPrivacyPoliciesForBrand',
|
|
12143
12985
|
version='2021-12-01',
|
|
12144
12986
|
protocol='HTTPS',
|
|
12145
12987
|
pathname='/',
|
|
@@ -12150,33 +12992,39 @@ class Client(OpenApiClient):
|
|
|
12150
12992
|
body_type='json'
|
|
12151
12993
|
)
|
|
12152
12994
|
return TeaCore.from_map(
|
|
12153
|
-
eiam_20211201_models.
|
|
12995
|
+
eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse(),
|
|
12154
12996
|
self.call_api(params, req, runtime)
|
|
12155
12997
|
)
|
|
12156
12998
|
|
|
12157
|
-
async def
|
|
12999
|
+
async def list_custom_privacy_policies_for_brand_with_options_async(
|
|
12158
13000
|
self,
|
|
12159
|
-
request: eiam_20211201_models.
|
|
13001
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesForBrandRequest,
|
|
12160
13002
|
runtime: util_models.RuntimeOptions,
|
|
12161
|
-
) -> eiam_20211201_models.
|
|
13003
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse:
|
|
12162
13004
|
"""
|
|
12163
|
-
@summary
|
|
13005
|
+
@summary 获取品牌关联资源的资源
|
|
12164
13006
|
|
|
12165
|
-
@param request:
|
|
13007
|
+
@param request: ListCustomPrivacyPoliciesForBrandRequest
|
|
12166
13008
|
@param runtime: runtime options for this request RuntimeOptions
|
|
12167
|
-
@return:
|
|
13009
|
+
@return: ListCustomPrivacyPoliciesForBrandResponse
|
|
12168
13010
|
"""
|
|
12169
13011
|
UtilClient.validate_model(request)
|
|
12170
13012
|
query = {}
|
|
13013
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
13014
|
+
query['BrandId'] = request.brand_id
|
|
12171
13015
|
if not UtilClient.is_unset(request.instance_id):
|
|
12172
13016
|
query['InstanceId'] = request.instance_id
|
|
12173
|
-
if not UtilClient.is_unset(request.
|
|
12174
|
-
query['
|
|
13017
|
+
if not UtilClient.is_unset(request.max_results):
|
|
13018
|
+
query['MaxResults'] = request.max_results
|
|
13019
|
+
if not UtilClient.is_unset(request.next_token):
|
|
13020
|
+
query['NextToken'] = request.next_token
|
|
13021
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
13022
|
+
query['PreviousToken'] = request.previous_token
|
|
12175
13023
|
req = open_api_models.OpenApiRequest(
|
|
12176
13024
|
query=OpenApiUtilClient.query(query)
|
|
12177
13025
|
)
|
|
12178
13026
|
params = open_api_models.Params(
|
|
12179
|
-
action='
|
|
13027
|
+
action='ListCustomPrivacyPoliciesForBrand',
|
|
12180
13028
|
version='2021-12-01',
|
|
12181
13029
|
protocol='HTTPS',
|
|
12182
13030
|
pathname='/',
|
|
@@ -12187,35 +13035,35 @@ class Client(OpenApiClient):
|
|
|
12187
13035
|
body_type='json'
|
|
12188
13036
|
)
|
|
12189
13037
|
return TeaCore.from_map(
|
|
12190
|
-
eiam_20211201_models.
|
|
13038
|
+
eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse(),
|
|
12191
13039
|
await self.call_api_async(params, req, runtime)
|
|
12192
13040
|
)
|
|
12193
13041
|
|
|
12194
|
-
def
|
|
13042
|
+
def list_custom_privacy_policies_for_brand(
|
|
12195
13043
|
self,
|
|
12196
|
-
request: eiam_20211201_models.
|
|
12197
|
-
) -> eiam_20211201_models.
|
|
13044
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesForBrandRequest,
|
|
13045
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse:
|
|
12198
13046
|
"""
|
|
12199
|
-
@summary
|
|
13047
|
+
@summary 获取品牌关联资源的资源
|
|
12200
13048
|
|
|
12201
|
-
@param request:
|
|
12202
|
-
@return:
|
|
13049
|
+
@param request: ListCustomPrivacyPoliciesForBrandRequest
|
|
13050
|
+
@return: ListCustomPrivacyPoliciesForBrandResponse
|
|
12203
13051
|
"""
|
|
12204
13052
|
runtime = util_models.RuntimeOptions()
|
|
12205
|
-
return self.
|
|
13053
|
+
return self.list_custom_privacy_policies_for_brand_with_options(request, runtime)
|
|
12206
13054
|
|
|
12207
|
-
async def
|
|
13055
|
+
async def list_custom_privacy_policies_for_brand_async(
|
|
12208
13056
|
self,
|
|
12209
|
-
request: eiam_20211201_models.
|
|
12210
|
-
) -> eiam_20211201_models.
|
|
13057
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesForBrandRequest,
|
|
13058
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse:
|
|
12211
13059
|
"""
|
|
12212
|
-
@summary
|
|
13060
|
+
@summary 获取品牌关联资源的资源
|
|
12213
13061
|
|
|
12214
|
-
@param request:
|
|
12215
|
-
@return:
|
|
13062
|
+
@param request: ListCustomPrivacyPoliciesForBrandRequest
|
|
13063
|
+
@return: ListCustomPrivacyPoliciesForBrandResponse
|
|
12216
13064
|
"""
|
|
12217
13065
|
runtime = util_models.RuntimeOptions()
|
|
12218
|
-
return await self.
|
|
13066
|
+
return await self.list_custom_privacy_policies_for_brand_with_options_async(request, runtime)
|
|
12219
13067
|
|
|
12220
13068
|
def list_domain_proxy_tokens_with_options(
|
|
12221
13069
|
self,
|
|
@@ -15207,6 +16055,110 @@ class Client(OpenApiClient):
|
|
|
15207
16055
|
runtime = util_models.RuntimeOptions()
|
|
15208
16056
|
return await self.remove_application_account_from_user_with_options_async(request, runtime)
|
|
15209
16057
|
|
|
16058
|
+
def remove_custom_privacy_policies_from_brand_with_options(
|
|
16059
|
+
self,
|
|
16060
|
+
request: eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandRequest,
|
|
16061
|
+
runtime: util_models.RuntimeOptions,
|
|
16062
|
+
) -> eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse:
|
|
16063
|
+
"""
|
|
16064
|
+
@summary 移除品牌关联条款
|
|
16065
|
+
|
|
16066
|
+
@param request: RemoveCustomPrivacyPoliciesFromBrandRequest
|
|
16067
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
16068
|
+
@return: RemoveCustomPrivacyPoliciesFromBrandResponse
|
|
16069
|
+
"""
|
|
16070
|
+
UtilClient.validate_model(request)
|
|
16071
|
+
query = {}
|
|
16072
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
16073
|
+
query['BrandId'] = request.brand_id
|
|
16074
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_ids):
|
|
16075
|
+
query['CustomPrivacyPolicyIds'] = request.custom_privacy_policy_ids
|
|
16076
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
16077
|
+
query['InstanceId'] = request.instance_id
|
|
16078
|
+
req = open_api_models.OpenApiRequest(
|
|
16079
|
+
query=OpenApiUtilClient.query(query)
|
|
16080
|
+
)
|
|
16081
|
+
params = open_api_models.Params(
|
|
16082
|
+
action='RemoveCustomPrivacyPoliciesFromBrand',
|
|
16083
|
+
version='2021-12-01',
|
|
16084
|
+
protocol='HTTPS',
|
|
16085
|
+
pathname='/',
|
|
16086
|
+
method='POST',
|
|
16087
|
+
auth_type='AK',
|
|
16088
|
+
style='RPC',
|
|
16089
|
+
req_body_type='formData',
|
|
16090
|
+
body_type='json'
|
|
16091
|
+
)
|
|
16092
|
+
return TeaCore.from_map(
|
|
16093
|
+
eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse(),
|
|
16094
|
+
self.call_api(params, req, runtime)
|
|
16095
|
+
)
|
|
16096
|
+
|
|
16097
|
+
async def remove_custom_privacy_policies_from_brand_with_options_async(
|
|
16098
|
+
self,
|
|
16099
|
+
request: eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandRequest,
|
|
16100
|
+
runtime: util_models.RuntimeOptions,
|
|
16101
|
+
) -> eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse:
|
|
16102
|
+
"""
|
|
16103
|
+
@summary 移除品牌关联条款
|
|
16104
|
+
|
|
16105
|
+
@param request: RemoveCustomPrivacyPoliciesFromBrandRequest
|
|
16106
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
16107
|
+
@return: RemoveCustomPrivacyPoliciesFromBrandResponse
|
|
16108
|
+
"""
|
|
16109
|
+
UtilClient.validate_model(request)
|
|
16110
|
+
query = {}
|
|
16111
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
16112
|
+
query['BrandId'] = request.brand_id
|
|
16113
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_ids):
|
|
16114
|
+
query['CustomPrivacyPolicyIds'] = request.custom_privacy_policy_ids
|
|
16115
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
16116
|
+
query['InstanceId'] = request.instance_id
|
|
16117
|
+
req = open_api_models.OpenApiRequest(
|
|
16118
|
+
query=OpenApiUtilClient.query(query)
|
|
16119
|
+
)
|
|
16120
|
+
params = open_api_models.Params(
|
|
16121
|
+
action='RemoveCustomPrivacyPoliciesFromBrand',
|
|
16122
|
+
version='2021-12-01',
|
|
16123
|
+
protocol='HTTPS',
|
|
16124
|
+
pathname='/',
|
|
16125
|
+
method='POST',
|
|
16126
|
+
auth_type='AK',
|
|
16127
|
+
style='RPC',
|
|
16128
|
+
req_body_type='formData',
|
|
16129
|
+
body_type='json'
|
|
16130
|
+
)
|
|
16131
|
+
return TeaCore.from_map(
|
|
16132
|
+
eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse(),
|
|
16133
|
+
await self.call_api_async(params, req, runtime)
|
|
16134
|
+
)
|
|
16135
|
+
|
|
16136
|
+
def remove_custom_privacy_policies_from_brand(
|
|
16137
|
+
self,
|
|
16138
|
+
request: eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandRequest,
|
|
16139
|
+
) -> eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse:
|
|
16140
|
+
"""
|
|
16141
|
+
@summary 移除品牌关联条款
|
|
16142
|
+
|
|
16143
|
+
@param request: RemoveCustomPrivacyPoliciesFromBrandRequest
|
|
16144
|
+
@return: RemoveCustomPrivacyPoliciesFromBrandResponse
|
|
16145
|
+
"""
|
|
16146
|
+
runtime = util_models.RuntimeOptions()
|
|
16147
|
+
return self.remove_custom_privacy_policies_from_brand_with_options(request, runtime)
|
|
16148
|
+
|
|
16149
|
+
async def remove_custom_privacy_policies_from_brand_async(
|
|
16150
|
+
self,
|
|
16151
|
+
request: eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandRequest,
|
|
16152
|
+
) -> eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse:
|
|
16153
|
+
"""
|
|
16154
|
+
@summary 移除品牌关联条款
|
|
16155
|
+
|
|
16156
|
+
@param request: RemoveCustomPrivacyPoliciesFromBrandRequest
|
|
16157
|
+
@return: RemoveCustomPrivacyPoliciesFromBrandResponse
|
|
16158
|
+
"""
|
|
16159
|
+
runtime = util_models.RuntimeOptions()
|
|
16160
|
+
return await self.remove_custom_privacy_policies_from_brand_with_options_async(request, runtime)
|
|
16161
|
+
|
|
15210
16162
|
def remove_user_from_organizational_units_with_options(
|
|
15211
16163
|
self,
|
|
15212
16164
|
request: eiam_20211201_models.RemoveUserFromOrganizationalUnitsRequest,
|
|
@@ -18507,6 +19459,122 @@ class Client(OpenApiClient):
|
|
|
18507
19459
|
runtime = util_models.RuntimeOptions()
|
|
18508
19460
|
return await self.update_conditional_access_policy_description_with_options_async(request, runtime)
|
|
18509
19461
|
|
|
19462
|
+
def update_custom_privacy_policy_with_options(
|
|
19463
|
+
self,
|
|
19464
|
+
request: eiam_20211201_models.UpdateCustomPrivacyPolicyRequest,
|
|
19465
|
+
runtime: util_models.RuntimeOptions,
|
|
19466
|
+
) -> eiam_20211201_models.UpdateCustomPrivacyPolicyResponse:
|
|
19467
|
+
"""
|
|
19468
|
+
@summary 更新自定义条款
|
|
19469
|
+
|
|
19470
|
+
@param request: UpdateCustomPrivacyPolicyRequest
|
|
19471
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
19472
|
+
@return: UpdateCustomPrivacyPolicyResponse
|
|
19473
|
+
"""
|
|
19474
|
+
UtilClient.validate_model(request)
|
|
19475
|
+
query = {}
|
|
19476
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_contents):
|
|
19477
|
+
query['CustomPrivacyPolicyContents'] = request.custom_privacy_policy_contents
|
|
19478
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
19479
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
19480
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name):
|
|
19481
|
+
query['CustomPrivacyPolicyName'] = request.custom_privacy_policy_name
|
|
19482
|
+
if not UtilClient.is_unset(request.default_language_code):
|
|
19483
|
+
query['DefaultLanguageCode'] = request.default_language_code
|
|
19484
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
19485
|
+
query['InstanceId'] = request.instance_id
|
|
19486
|
+
if not UtilClient.is_unset(request.user_consent_type):
|
|
19487
|
+
query['UserConsentType'] = request.user_consent_type
|
|
19488
|
+
req = open_api_models.OpenApiRequest(
|
|
19489
|
+
query=OpenApiUtilClient.query(query)
|
|
19490
|
+
)
|
|
19491
|
+
params = open_api_models.Params(
|
|
19492
|
+
action='UpdateCustomPrivacyPolicy',
|
|
19493
|
+
version='2021-12-01',
|
|
19494
|
+
protocol='HTTPS',
|
|
19495
|
+
pathname='/',
|
|
19496
|
+
method='POST',
|
|
19497
|
+
auth_type='AK',
|
|
19498
|
+
style='RPC',
|
|
19499
|
+
req_body_type='formData',
|
|
19500
|
+
body_type='json'
|
|
19501
|
+
)
|
|
19502
|
+
return TeaCore.from_map(
|
|
19503
|
+
eiam_20211201_models.UpdateCustomPrivacyPolicyResponse(),
|
|
19504
|
+
self.call_api(params, req, runtime)
|
|
19505
|
+
)
|
|
19506
|
+
|
|
19507
|
+
async def update_custom_privacy_policy_with_options_async(
|
|
19508
|
+
self,
|
|
19509
|
+
request: eiam_20211201_models.UpdateCustomPrivacyPolicyRequest,
|
|
19510
|
+
runtime: util_models.RuntimeOptions,
|
|
19511
|
+
) -> eiam_20211201_models.UpdateCustomPrivacyPolicyResponse:
|
|
19512
|
+
"""
|
|
19513
|
+
@summary 更新自定义条款
|
|
19514
|
+
|
|
19515
|
+
@param request: UpdateCustomPrivacyPolicyRequest
|
|
19516
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
19517
|
+
@return: UpdateCustomPrivacyPolicyResponse
|
|
19518
|
+
"""
|
|
19519
|
+
UtilClient.validate_model(request)
|
|
19520
|
+
query = {}
|
|
19521
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_contents):
|
|
19522
|
+
query['CustomPrivacyPolicyContents'] = request.custom_privacy_policy_contents
|
|
19523
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
19524
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
19525
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name):
|
|
19526
|
+
query['CustomPrivacyPolicyName'] = request.custom_privacy_policy_name
|
|
19527
|
+
if not UtilClient.is_unset(request.default_language_code):
|
|
19528
|
+
query['DefaultLanguageCode'] = request.default_language_code
|
|
19529
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
19530
|
+
query['InstanceId'] = request.instance_id
|
|
19531
|
+
if not UtilClient.is_unset(request.user_consent_type):
|
|
19532
|
+
query['UserConsentType'] = request.user_consent_type
|
|
19533
|
+
req = open_api_models.OpenApiRequest(
|
|
19534
|
+
query=OpenApiUtilClient.query(query)
|
|
19535
|
+
)
|
|
19536
|
+
params = open_api_models.Params(
|
|
19537
|
+
action='UpdateCustomPrivacyPolicy',
|
|
19538
|
+
version='2021-12-01',
|
|
19539
|
+
protocol='HTTPS',
|
|
19540
|
+
pathname='/',
|
|
19541
|
+
method='POST',
|
|
19542
|
+
auth_type='AK',
|
|
19543
|
+
style='RPC',
|
|
19544
|
+
req_body_type='formData',
|
|
19545
|
+
body_type='json'
|
|
19546
|
+
)
|
|
19547
|
+
return TeaCore.from_map(
|
|
19548
|
+
eiam_20211201_models.UpdateCustomPrivacyPolicyResponse(),
|
|
19549
|
+
await self.call_api_async(params, req, runtime)
|
|
19550
|
+
)
|
|
19551
|
+
|
|
19552
|
+
def update_custom_privacy_policy(
|
|
19553
|
+
self,
|
|
19554
|
+
request: eiam_20211201_models.UpdateCustomPrivacyPolicyRequest,
|
|
19555
|
+
) -> eiam_20211201_models.UpdateCustomPrivacyPolicyResponse:
|
|
19556
|
+
"""
|
|
19557
|
+
@summary 更新自定义条款
|
|
19558
|
+
|
|
19559
|
+
@param request: UpdateCustomPrivacyPolicyRequest
|
|
19560
|
+
@return: UpdateCustomPrivacyPolicyResponse
|
|
19561
|
+
"""
|
|
19562
|
+
runtime = util_models.RuntimeOptions()
|
|
19563
|
+
return self.update_custom_privacy_policy_with_options(request, runtime)
|
|
19564
|
+
|
|
19565
|
+
async def update_custom_privacy_policy_async(
|
|
19566
|
+
self,
|
|
19567
|
+
request: eiam_20211201_models.UpdateCustomPrivacyPolicyRequest,
|
|
19568
|
+
) -> eiam_20211201_models.UpdateCustomPrivacyPolicyResponse:
|
|
19569
|
+
"""
|
|
19570
|
+
@summary 更新自定义条款
|
|
19571
|
+
|
|
19572
|
+
@param request: UpdateCustomPrivacyPolicyRequest
|
|
19573
|
+
@return: UpdateCustomPrivacyPolicyResponse
|
|
19574
|
+
"""
|
|
19575
|
+
runtime = util_models.RuntimeOptions()
|
|
19576
|
+
return await self.update_custom_privacy_policy_with_options_async(request, runtime)
|
|
19577
|
+
|
|
18510
19578
|
def update_domain_brand_with_options(
|
|
18511
19579
|
self,
|
|
18512
19580
|
request: eiam_20211201_models.UpdateDomainBrandRequest,
|