alibabacloud-eiam20211201 2.3.0__py3-none-any.whl → 2.5.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 +1496 -92
- alibabacloud_eiam20211201/models.py +2535 -333
- {alibabacloud_eiam20211201-2.3.0.dist-info → alibabacloud_eiam20211201-2.5.0.dist-info}/METADATA +1 -1
- alibabacloud_eiam20211201-2.5.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.5.0.dist-info}/LICENSE +0 -0
- {alibabacloud_eiam20211201-2.3.0.dist-info → alibabacloud_eiam20211201-2.5.0.dist-info}/WHEEL +0 -0
- {alibabacloud_eiam20211201-2.3.0.dist-info → alibabacloud_eiam20211201-2.5.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,
|
|
@@ -669,6 +773,114 @@ class Client(OpenApiClient):
|
|
|
669
773
|
runtime = util_models.RuntimeOptions()
|
|
670
774
|
return await self.authorize_application_to_users_with_options_async(request, runtime)
|
|
671
775
|
|
|
776
|
+
def bind_user_authn_source_mapping_with_options(
|
|
777
|
+
self,
|
|
778
|
+
request: eiam_20211201_models.BindUserAuthnSourceMappingRequest,
|
|
779
|
+
runtime: util_models.RuntimeOptions,
|
|
780
|
+
) -> eiam_20211201_models.BindUserAuthnSourceMappingResponse:
|
|
781
|
+
"""
|
|
782
|
+
@summary 绑定三方登录账户
|
|
783
|
+
|
|
784
|
+
@param request: BindUserAuthnSourceMappingRequest
|
|
785
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
786
|
+
@return: BindUserAuthnSourceMappingResponse
|
|
787
|
+
"""
|
|
788
|
+
UtilClient.validate_model(request)
|
|
789
|
+
query = {}
|
|
790
|
+
if not UtilClient.is_unset(request.identity_provider_id):
|
|
791
|
+
query['IdentityProviderId'] = request.identity_provider_id
|
|
792
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
793
|
+
query['InstanceId'] = request.instance_id
|
|
794
|
+
if not UtilClient.is_unset(request.user_external_id):
|
|
795
|
+
query['UserExternalId'] = request.user_external_id
|
|
796
|
+
if not UtilClient.is_unset(request.user_id):
|
|
797
|
+
query['UserId'] = request.user_id
|
|
798
|
+
req = open_api_models.OpenApiRequest(
|
|
799
|
+
query=OpenApiUtilClient.query(query)
|
|
800
|
+
)
|
|
801
|
+
params = open_api_models.Params(
|
|
802
|
+
action='BindUserAuthnSourceMapping',
|
|
803
|
+
version='2021-12-01',
|
|
804
|
+
protocol='HTTPS',
|
|
805
|
+
pathname='/',
|
|
806
|
+
method='POST',
|
|
807
|
+
auth_type='AK',
|
|
808
|
+
style='RPC',
|
|
809
|
+
req_body_type='formData',
|
|
810
|
+
body_type='json'
|
|
811
|
+
)
|
|
812
|
+
return TeaCore.from_map(
|
|
813
|
+
eiam_20211201_models.BindUserAuthnSourceMappingResponse(),
|
|
814
|
+
self.call_api(params, req, runtime)
|
|
815
|
+
)
|
|
816
|
+
|
|
817
|
+
async def bind_user_authn_source_mapping_with_options_async(
|
|
818
|
+
self,
|
|
819
|
+
request: eiam_20211201_models.BindUserAuthnSourceMappingRequest,
|
|
820
|
+
runtime: util_models.RuntimeOptions,
|
|
821
|
+
) -> eiam_20211201_models.BindUserAuthnSourceMappingResponse:
|
|
822
|
+
"""
|
|
823
|
+
@summary 绑定三方登录账户
|
|
824
|
+
|
|
825
|
+
@param request: BindUserAuthnSourceMappingRequest
|
|
826
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
827
|
+
@return: BindUserAuthnSourceMappingResponse
|
|
828
|
+
"""
|
|
829
|
+
UtilClient.validate_model(request)
|
|
830
|
+
query = {}
|
|
831
|
+
if not UtilClient.is_unset(request.identity_provider_id):
|
|
832
|
+
query['IdentityProviderId'] = request.identity_provider_id
|
|
833
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
834
|
+
query['InstanceId'] = request.instance_id
|
|
835
|
+
if not UtilClient.is_unset(request.user_external_id):
|
|
836
|
+
query['UserExternalId'] = request.user_external_id
|
|
837
|
+
if not UtilClient.is_unset(request.user_id):
|
|
838
|
+
query['UserId'] = request.user_id
|
|
839
|
+
req = open_api_models.OpenApiRequest(
|
|
840
|
+
query=OpenApiUtilClient.query(query)
|
|
841
|
+
)
|
|
842
|
+
params = open_api_models.Params(
|
|
843
|
+
action='BindUserAuthnSourceMapping',
|
|
844
|
+
version='2021-12-01',
|
|
845
|
+
protocol='HTTPS',
|
|
846
|
+
pathname='/',
|
|
847
|
+
method='POST',
|
|
848
|
+
auth_type='AK',
|
|
849
|
+
style='RPC',
|
|
850
|
+
req_body_type='formData',
|
|
851
|
+
body_type='json'
|
|
852
|
+
)
|
|
853
|
+
return TeaCore.from_map(
|
|
854
|
+
eiam_20211201_models.BindUserAuthnSourceMappingResponse(),
|
|
855
|
+
await self.call_api_async(params, req, runtime)
|
|
856
|
+
)
|
|
857
|
+
|
|
858
|
+
def bind_user_authn_source_mapping(
|
|
859
|
+
self,
|
|
860
|
+
request: eiam_20211201_models.BindUserAuthnSourceMappingRequest,
|
|
861
|
+
) -> eiam_20211201_models.BindUserAuthnSourceMappingResponse:
|
|
862
|
+
"""
|
|
863
|
+
@summary 绑定三方登录账户
|
|
864
|
+
|
|
865
|
+
@param request: BindUserAuthnSourceMappingRequest
|
|
866
|
+
@return: BindUserAuthnSourceMappingResponse
|
|
867
|
+
"""
|
|
868
|
+
runtime = util_models.RuntimeOptions()
|
|
869
|
+
return self.bind_user_authn_source_mapping_with_options(request, runtime)
|
|
870
|
+
|
|
871
|
+
async def bind_user_authn_source_mapping_async(
|
|
872
|
+
self,
|
|
873
|
+
request: eiam_20211201_models.BindUserAuthnSourceMappingRequest,
|
|
874
|
+
) -> eiam_20211201_models.BindUserAuthnSourceMappingResponse:
|
|
875
|
+
"""
|
|
876
|
+
@summary 绑定三方登录账户
|
|
877
|
+
|
|
878
|
+
@param request: BindUserAuthnSourceMappingRequest
|
|
879
|
+
@return: BindUserAuthnSourceMappingResponse
|
|
880
|
+
"""
|
|
881
|
+
runtime = util_models.RuntimeOptions()
|
|
882
|
+
return await self.bind_user_authn_source_mapping_with_options_async(request, runtime)
|
|
883
|
+
|
|
672
884
|
def create_application_with_options(
|
|
673
885
|
self,
|
|
674
886
|
request: eiam_20211201_models.CreateApplicationRequest,
|
|
@@ -1373,6 +1585,126 @@ class Client(OpenApiClient):
|
|
|
1373
1585
|
runtime = util_models.RuntimeOptions()
|
|
1374
1586
|
return await self.create_conditional_access_policy_with_options_async(request, runtime)
|
|
1375
1587
|
|
|
1588
|
+
def create_custom_privacy_policy_with_options(
|
|
1589
|
+
self,
|
|
1590
|
+
request: eiam_20211201_models.CreateCustomPrivacyPolicyRequest,
|
|
1591
|
+
runtime: util_models.RuntimeOptions,
|
|
1592
|
+
) -> eiam_20211201_models.CreateCustomPrivacyPolicyResponse:
|
|
1593
|
+
"""
|
|
1594
|
+
@summary 创建自定义条款
|
|
1595
|
+
|
|
1596
|
+
@param request: CreateCustomPrivacyPolicyRequest
|
|
1597
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1598
|
+
@return: CreateCustomPrivacyPolicyResponse
|
|
1599
|
+
"""
|
|
1600
|
+
UtilClient.validate_model(request)
|
|
1601
|
+
query = {}
|
|
1602
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1603
|
+
query['ClientToken'] = request.client_token
|
|
1604
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_contents):
|
|
1605
|
+
query['CustomPrivacyPolicyContents'] = request.custom_privacy_policy_contents
|
|
1606
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name):
|
|
1607
|
+
query['CustomPrivacyPolicyName'] = request.custom_privacy_policy_name
|
|
1608
|
+
if not UtilClient.is_unset(request.default_language_code):
|
|
1609
|
+
query['DefaultLanguageCode'] = request.default_language_code
|
|
1610
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
1611
|
+
query['InstanceId'] = request.instance_id
|
|
1612
|
+
if not UtilClient.is_unset(request.status):
|
|
1613
|
+
query['Status'] = request.status
|
|
1614
|
+
if not UtilClient.is_unset(request.user_consent_type):
|
|
1615
|
+
query['UserConsentType'] = request.user_consent_type
|
|
1616
|
+
req = open_api_models.OpenApiRequest(
|
|
1617
|
+
query=OpenApiUtilClient.query(query)
|
|
1618
|
+
)
|
|
1619
|
+
params = open_api_models.Params(
|
|
1620
|
+
action='CreateCustomPrivacyPolicy',
|
|
1621
|
+
version='2021-12-01',
|
|
1622
|
+
protocol='HTTPS',
|
|
1623
|
+
pathname='/',
|
|
1624
|
+
method='POST',
|
|
1625
|
+
auth_type='AK',
|
|
1626
|
+
style='RPC',
|
|
1627
|
+
req_body_type='formData',
|
|
1628
|
+
body_type='json'
|
|
1629
|
+
)
|
|
1630
|
+
return TeaCore.from_map(
|
|
1631
|
+
eiam_20211201_models.CreateCustomPrivacyPolicyResponse(),
|
|
1632
|
+
self.call_api(params, req, runtime)
|
|
1633
|
+
)
|
|
1634
|
+
|
|
1635
|
+
async def create_custom_privacy_policy_with_options_async(
|
|
1636
|
+
self,
|
|
1637
|
+
request: eiam_20211201_models.CreateCustomPrivacyPolicyRequest,
|
|
1638
|
+
runtime: util_models.RuntimeOptions,
|
|
1639
|
+
) -> eiam_20211201_models.CreateCustomPrivacyPolicyResponse:
|
|
1640
|
+
"""
|
|
1641
|
+
@summary 创建自定义条款
|
|
1642
|
+
|
|
1643
|
+
@param request: CreateCustomPrivacyPolicyRequest
|
|
1644
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1645
|
+
@return: CreateCustomPrivacyPolicyResponse
|
|
1646
|
+
"""
|
|
1647
|
+
UtilClient.validate_model(request)
|
|
1648
|
+
query = {}
|
|
1649
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1650
|
+
query['ClientToken'] = request.client_token
|
|
1651
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_contents):
|
|
1652
|
+
query['CustomPrivacyPolicyContents'] = request.custom_privacy_policy_contents
|
|
1653
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name):
|
|
1654
|
+
query['CustomPrivacyPolicyName'] = request.custom_privacy_policy_name
|
|
1655
|
+
if not UtilClient.is_unset(request.default_language_code):
|
|
1656
|
+
query['DefaultLanguageCode'] = request.default_language_code
|
|
1657
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
1658
|
+
query['InstanceId'] = request.instance_id
|
|
1659
|
+
if not UtilClient.is_unset(request.status):
|
|
1660
|
+
query['Status'] = request.status
|
|
1661
|
+
if not UtilClient.is_unset(request.user_consent_type):
|
|
1662
|
+
query['UserConsentType'] = request.user_consent_type
|
|
1663
|
+
req = open_api_models.OpenApiRequest(
|
|
1664
|
+
query=OpenApiUtilClient.query(query)
|
|
1665
|
+
)
|
|
1666
|
+
params = open_api_models.Params(
|
|
1667
|
+
action='CreateCustomPrivacyPolicy',
|
|
1668
|
+
version='2021-12-01',
|
|
1669
|
+
protocol='HTTPS',
|
|
1670
|
+
pathname='/',
|
|
1671
|
+
method='POST',
|
|
1672
|
+
auth_type='AK',
|
|
1673
|
+
style='RPC',
|
|
1674
|
+
req_body_type='formData',
|
|
1675
|
+
body_type='json'
|
|
1676
|
+
)
|
|
1677
|
+
return TeaCore.from_map(
|
|
1678
|
+
eiam_20211201_models.CreateCustomPrivacyPolicyResponse(),
|
|
1679
|
+
await self.call_api_async(params, req, runtime)
|
|
1680
|
+
)
|
|
1681
|
+
|
|
1682
|
+
def create_custom_privacy_policy(
|
|
1683
|
+
self,
|
|
1684
|
+
request: eiam_20211201_models.CreateCustomPrivacyPolicyRequest,
|
|
1685
|
+
) -> eiam_20211201_models.CreateCustomPrivacyPolicyResponse:
|
|
1686
|
+
"""
|
|
1687
|
+
@summary 创建自定义条款
|
|
1688
|
+
|
|
1689
|
+
@param request: CreateCustomPrivacyPolicyRequest
|
|
1690
|
+
@return: CreateCustomPrivacyPolicyResponse
|
|
1691
|
+
"""
|
|
1692
|
+
runtime = util_models.RuntimeOptions()
|
|
1693
|
+
return self.create_custom_privacy_policy_with_options(request, runtime)
|
|
1694
|
+
|
|
1695
|
+
async def create_custom_privacy_policy_async(
|
|
1696
|
+
self,
|
|
1697
|
+
request: eiam_20211201_models.CreateCustomPrivacyPolicyRequest,
|
|
1698
|
+
) -> eiam_20211201_models.CreateCustomPrivacyPolicyResponse:
|
|
1699
|
+
"""
|
|
1700
|
+
@summary 创建自定义条款
|
|
1701
|
+
|
|
1702
|
+
@param request: CreateCustomPrivacyPolicyRequest
|
|
1703
|
+
@return: CreateCustomPrivacyPolicyResponse
|
|
1704
|
+
"""
|
|
1705
|
+
runtime = util_models.RuntimeOptions()
|
|
1706
|
+
return await self.create_custom_privacy_policy_with_options_async(request, runtime)
|
|
1707
|
+
|
|
1376
1708
|
def create_domain_with_options(
|
|
1377
1709
|
self,
|
|
1378
1710
|
request: eiam_20211201_models.CreateDomainRequest,
|
|
@@ -3201,29 +3533,29 @@ class Client(OpenApiClient):
|
|
|
3201
3533
|
runtime = util_models.RuntimeOptions()
|
|
3202
3534
|
return await self.delete_conditional_access_policy_with_options_async(request, runtime)
|
|
3203
3535
|
|
|
3204
|
-
def
|
|
3536
|
+
def delete_custom_privacy_policy_with_options(
|
|
3205
3537
|
self,
|
|
3206
|
-
request: eiam_20211201_models.
|
|
3538
|
+
request: eiam_20211201_models.DeleteCustomPrivacyPolicyRequest,
|
|
3207
3539
|
runtime: util_models.RuntimeOptions,
|
|
3208
|
-
) -> eiam_20211201_models.
|
|
3540
|
+
) -> eiam_20211201_models.DeleteCustomPrivacyPolicyResponse:
|
|
3209
3541
|
"""
|
|
3210
|
-
@summary
|
|
3542
|
+
@summary 删除自定义条款
|
|
3211
3543
|
|
|
3212
|
-
@param request:
|
|
3544
|
+
@param request: DeleteCustomPrivacyPolicyRequest
|
|
3213
3545
|
@param runtime: runtime options for this request RuntimeOptions
|
|
3214
|
-
@return:
|
|
3546
|
+
@return: DeleteCustomPrivacyPolicyResponse
|
|
3215
3547
|
"""
|
|
3216
3548
|
UtilClient.validate_model(request)
|
|
3217
3549
|
query = {}
|
|
3218
|
-
if not UtilClient.is_unset(request.
|
|
3219
|
-
query['
|
|
3550
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
3551
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
3220
3552
|
if not UtilClient.is_unset(request.instance_id):
|
|
3221
3553
|
query['InstanceId'] = request.instance_id
|
|
3222
3554
|
req = open_api_models.OpenApiRequest(
|
|
3223
3555
|
query=OpenApiUtilClient.query(query)
|
|
3224
3556
|
)
|
|
3225
3557
|
params = open_api_models.Params(
|
|
3226
|
-
action='
|
|
3558
|
+
action='DeleteCustomPrivacyPolicy',
|
|
3227
3559
|
version='2021-12-01',
|
|
3228
3560
|
protocol='HTTPS',
|
|
3229
3561
|
pathname='/',
|
|
@@ -3234,33 +3566,33 @@ class Client(OpenApiClient):
|
|
|
3234
3566
|
body_type='json'
|
|
3235
3567
|
)
|
|
3236
3568
|
return TeaCore.from_map(
|
|
3237
|
-
eiam_20211201_models.
|
|
3569
|
+
eiam_20211201_models.DeleteCustomPrivacyPolicyResponse(),
|
|
3238
3570
|
self.call_api(params, req, runtime)
|
|
3239
3571
|
)
|
|
3240
3572
|
|
|
3241
|
-
async def
|
|
3573
|
+
async def delete_custom_privacy_policy_with_options_async(
|
|
3242
3574
|
self,
|
|
3243
|
-
request: eiam_20211201_models.
|
|
3575
|
+
request: eiam_20211201_models.DeleteCustomPrivacyPolicyRequest,
|
|
3244
3576
|
runtime: util_models.RuntimeOptions,
|
|
3245
|
-
) -> eiam_20211201_models.
|
|
3577
|
+
) -> eiam_20211201_models.DeleteCustomPrivacyPolicyResponse:
|
|
3246
3578
|
"""
|
|
3247
|
-
@summary
|
|
3579
|
+
@summary 删除自定义条款
|
|
3248
3580
|
|
|
3249
|
-
@param request:
|
|
3581
|
+
@param request: DeleteCustomPrivacyPolicyRequest
|
|
3250
3582
|
@param runtime: runtime options for this request RuntimeOptions
|
|
3251
|
-
@return:
|
|
3583
|
+
@return: DeleteCustomPrivacyPolicyResponse
|
|
3252
3584
|
"""
|
|
3253
3585
|
UtilClient.validate_model(request)
|
|
3254
3586
|
query = {}
|
|
3255
|
-
if not UtilClient.is_unset(request.
|
|
3256
|
-
query['
|
|
3587
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
3588
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
3257
3589
|
if not UtilClient.is_unset(request.instance_id):
|
|
3258
3590
|
query['InstanceId'] = request.instance_id
|
|
3259
3591
|
req = open_api_models.OpenApiRequest(
|
|
3260
3592
|
query=OpenApiUtilClient.query(query)
|
|
3261
3593
|
)
|
|
3262
3594
|
params = open_api_models.Params(
|
|
3263
|
-
action='
|
|
3595
|
+
action='DeleteCustomPrivacyPolicy',
|
|
3264
3596
|
version='2021-12-01',
|
|
3265
3597
|
protocol='HTTPS',
|
|
3266
3598
|
pathname='/',
|
|
@@ -3271,35 +3603,135 @@ class Client(OpenApiClient):
|
|
|
3271
3603
|
body_type='json'
|
|
3272
3604
|
)
|
|
3273
3605
|
return TeaCore.from_map(
|
|
3274
|
-
eiam_20211201_models.
|
|
3606
|
+
eiam_20211201_models.DeleteCustomPrivacyPolicyResponse(),
|
|
3275
3607
|
await self.call_api_async(params, req, runtime)
|
|
3276
3608
|
)
|
|
3277
3609
|
|
|
3278
|
-
def
|
|
3610
|
+
def delete_custom_privacy_policy(
|
|
3279
3611
|
self,
|
|
3280
|
-
request: eiam_20211201_models.
|
|
3281
|
-
) -> eiam_20211201_models.
|
|
3612
|
+
request: eiam_20211201_models.DeleteCustomPrivacyPolicyRequest,
|
|
3613
|
+
) -> eiam_20211201_models.DeleteCustomPrivacyPolicyResponse:
|
|
3282
3614
|
"""
|
|
3283
|
-
@summary
|
|
3615
|
+
@summary 删除自定义条款
|
|
3284
3616
|
|
|
3285
|
-
@param request:
|
|
3286
|
-
@return:
|
|
3617
|
+
@param request: DeleteCustomPrivacyPolicyRequest
|
|
3618
|
+
@return: DeleteCustomPrivacyPolicyResponse
|
|
3287
3619
|
"""
|
|
3288
3620
|
runtime = util_models.RuntimeOptions()
|
|
3289
|
-
return self.
|
|
3621
|
+
return self.delete_custom_privacy_policy_with_options(request, runtime)
|
|
3290
3622
|
|
|
3291
|
-
async def
|
|
3623
|
+
async def delete_custom_privacy_policy_async(
|
|
3292
3624
|
self,
|
|
3293
|
-
request: eiam_20211201_models.
|
|
3294
|
-
) -> eiam_20211201_models.
|
|
3625
|
+
request: eiam_20211201_models.DeleteCustomPrivacyPolicyRequest,
|
|
3626
|
+
) -> eiam_20211201_models.DeleteCustomPrivacyPolicyResponse:
|
|
3295
3627
|
"""
|
|
3296
|
-
@summary
|
|
3628
|
+
@summary 删除自定义条款
|
|
3297
3629
|
|
|
3298
|
-
@param request:
|
|
3299
|
-
@return:
|
|
3630
|
+
@param request: DeleteCustomPrivacyPolicyRequest
|
|
3631
|
+
@return: DeleteCustomPrivacyPolicyResponse
|
|
3300
3632
|
"""
|
|
3301
3633
|
runtime = util_models.RuntimeOptions()
|
|
3302
|
-
return await self.
|
|
3634
|
+
return await self.delete_custom_privacy_policy_with_options_async(request, runtime)
|
|
3635
|
+
|
|
3636
|
+
def delete_domain_with_options(
|
|
3637
|
+
self,
|
|
3638
|
+
request: eiam_20211201_models.DeleteDomainRequest,
|
|
3639
|
+
runtime: util_models.RuntimeOptions,
|
|
3640
|
+
) -> eiam_20211201_models.DeleteDomainResponse:
|
|
3641
|
+
"""
|
|
3642
|
+
@summary Deletes a custom domain name of an Employee Identity and Access Management (EIAM) instance. You cannot delete the initial domain name and default domain name of the instance.
|
|
3643
|
+
|
|
3644
|
+
@param request: DeleteDomainRequest
|
|
3645
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3646
|
+
@return: DeleteDomainResponse
|
|
3647
|
+
"""
|
|
3648
|
+
UtilClient.validate_model(request)
|
|
3649
|
+
query = {}
|
|
3650
|
+
if not UtilClient.is_unset(request.domain_id):
|
|
3651
|
+
query['DomainId'] = request.domain_id
|
|
3652
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
3653
|
+
query['InstanceId'] = request.instance_id
|
|
3654
|
+
req = open_api_models.OpenApiRequest(
|
|
3655
|
+
query=OpenApiUtilClient.query(query)
|
|
3656
|
+
)
|
|
3657
|
+
params = open_api_models.Params(
|
|
3658
|
+
action='DeleteDomain',
|
|
3659
|
+
version='2021-12-01',
|
|
3660
|
+
protocol='HTTPS',
|
|
3661
|
+
pathname='/',
|
|
3662
|
+
method='POST',
|
|
3663
|
+
auth_type='AK',
|
|
3664
|
+
style='RPC',
|
|
3665
|
+
req_body_type='formData',
|
|
3666
|
+
body_type='json'
|
|
3667
|
+
)
|
|
3668
|
+
return TeaCore.from_map(
|
|
3669
|
+
eiam_20211201_models.DeleteDomainResponse(),
|
|
3670
|
+
self.call_api(params, req, runtime)
|
|
3671
|
+
)
|
|
3672
|
+
|
|
3673
|
+
async def delete_domain_with_options_async(
|
|
3674
|
+
self,
|
|
3675
|
+
request: eiam_20211201_models.DeleteDomainRequest,
|
|
3676
|
+
runtime: util_models.RuntimeOptions,
|
|
3677
|
+
) -> eiam_20211201_models.DeleteDomainResponse:
|
|
3678
|
+
"""
|
|
3679
|
+
@summary Deletes a custom domain name of an Employee Identity and Access Management (EIAM) instance. You cannot delete the initial domain name and default domain name of the instance.
|
|
3680
|
+
|
|
3681
|
+
@param request: DeleteDomainRequest
|
|
3682
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3683
|
+
@return: DeleteDomainResponse
|
|
3684
|
+
"""
|
|
3685
|
+
UtilClient.validate_model(request)
|
|
3686
|
+
query = {}
|
|
3687
|
+
if not UtilClient.is_unset(request.domain_id):
|
|
3688
|
+
query['DomainId'] = request.domain_id
|
|
3689
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
3690
|
+
query['InstanceId'] = request.instance_id
|
|
3691
|
+
req = open_api_models.OpenApiRequest(
|
|
3692
|
+
query=OpenApiUtilClient.query(query)
|
|
3693
|
+
)
|
|
3694
|
+
params = open_api_models.Params(
|
|
3695
|
+
action='DeleteDomain',
|
|
3696
|
+
version='2021-12-01',
|
|
3697
|
+
protocol='HTTPS',
|
|
3698
|
+
pathname='/',
|
|
3699
|
+
method='POST',
|
|
3700
|
+
auth_type='AK',
|
|
3701
|
+
style='RPC',
|
|
3702
|
+
req_body_type='formData',
|
|
3703
|
+
body_type='json'
|
|
3704
|
+
)
|
|
3705
|
+
return TeaCore.from_map(
|
|
3706
|
+
eiam_20211201_models.DeleteDomainResponse(),
|
|
3707
|
+
await self.call_api_async(params, req, runtime)
|
|
3708
|
+
)
|
|
3709
|
+
|
|
3710
|
+
def delete_domain(
|
|
3711
|
+
self,
|
|
3712
|
+
request: eiam_20211201_models.DeleteDomainRequest,
|
|
3713
|
+
) -> eiam_20211201_models.DeleteDomainResponse:
|
|
3714
|
+
"""
|
|
3715
|
+
@summary Deletes a custom domain name of an Employee Identity and Access Management (EIAM) instance. You cannot delete the initial domain name and default domain name of the instance.
|
|
3716
|
+
|
|
3717
|
+
@param request: DeleteDomainRequest
|
|
3718
|
+
@return: DeleteDomainResponse
|
|
3719
|
+
"""
|
|
3720
|
+
runtime = util_models.RuntimeOptions()
|
|
3721
|
+
return self.delete_domain_with_options(request, runtime)
|
|
3722
|
+
|
|
3723
|
+
async def delete_domain_async(
|
|
3724
|
+
self,
|
|
3725
|
+
request: eiam_20211201_models.DeleteDomainRequest,
|
|
3726
|
+
) -> eiam_20211201_models.DeleteDomainResponse:
|
|
3727
|
+
"""
|
|
3728
|
+
@summary Deletes a custom domain name of an Employee Identity and Access Management (EIAM) instance. You cannot delete the initial domain name and default domain name of the instance.
|
|
3729
|
+
|
|
3730
|
+
@param request: DeleteDomainRequest
|
|
3731
|
+
@return: DeleteDomainResponse
|
|
3732
|
+
"""
|
|
3733
|
+
runtime = util_models.RuntimeOptions()
|
|
3734
|
+
return await self.delete_domain_with_options_async(request, runtime)
|
|
3303
3735
|
|
|
3304
3736
|
def delete_domain_proxy_token_with_options(
|
|
3305
3737
|
self,
|
|
@@ -5237,6 +5669,106 @@ class Client(OpenApiClient):
|
|
|
5237
5669
|
runtime = util_models.RuntimeOptions()
|
|
5238
5670
|
return await self.disable_conditional_access_policy_with_options_async(request, runtime)
|
|
5239
5671
|
|
|
5672
|
+
def disable_custom_privacy_policy_with_options(
|
|
5673
|
+
self,
|
|
5674
|
+
request: eiam_20211201_models.DisableCustomPrivacyPolicyRequest,
|
|
5675
|
+
runtime: util_models.RuntimeOptions,
|
|
5676
|
+
) -> eiam_20211201_models.DisableCustomPrivacyPolicyResponse:
|
|
5677
|
+
"""
|
|
5678
|
+
@summary 禁用自定义条款
|
|
5679
|
+
|
|
5680
|
+
@param request: DisableCustomPrivacyPolicyRequest
|
|
5681
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
5682
|
+
@return: DisableCustomPrivacyPolicyResponse
|
|
5683
|
+
"""
|
|
5684
|
+
UtilClient.validate_model(request)
|
|
5685
|
+
query = {}
|
|
5686
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
5687
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
5688
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
5689
|
+
query['InstanceId'] = request.instance_id
|
|
5690
|
+
req = open_api_models.OpenApiRequest(
|
|
5691
|
+
query=OpenApiUtilClient.query(query)
|
|
5692
|
+
)
|
|
5693
|
+
params = open_api_models.Params(
|
|
5694
|
+
action='DisableCustomPrivacyPolicy',
|
|
5695
|
+
version='2021-12-01',
|
|
5696
|
+
protocol='HTTPS',
|
|
5697
|
+
pathname='/',
|
|
5698
|
+
method='POST',
|
|
5699
|
+
auth_type='AK',
|
|
5700
|
+
style='RPC',
|
|
5701
|
+
req_body_type='formData',
|
|
5702
|
+
body_type='json'
|
|
5703
|
+
)
|
|
5704
|
+
return TeaCore.from_map(
|
|
5705
|
+
eiam_20211201_models.DisableCustomPrivacyPolicyResponse(),
|
|
5706
|
+
self.call_api(params, req, runtime)
|
|
5707
|
+
)
|
|
5708
|
+
|
|
5709
|
+
async def disable_custom_privacy_policy_with_options_async(
|
|
5710
|
+
self,
|
|
5711
|
+
request: eiam_20211201_models.DisableCustomPrivacyPolicyRequest,
|
|
5712
|
+
runtime: util_models.RuntimeOptions,
|
|
5713
|
+
) -> eiam_20211201_models.DisableCustomPrivacyPolicyResponse:
|
|
5714
|
+
"""
|
|
5715
|
+
@summary 禁用自定义条款
|
|
5716
|
+
|
|
5717
|
+
@param request: DisableCustomPrivacyPolicyRequest
|
|
5718
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
5719
|
+
@return: DisableCustomPrivacyPolicyResponse
|
|
5720
|
+
"""
|
|
5721
|
+
UtilClient.validate_model(request)
|
|
5722
|
+
query = {}
|
|
5723
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
5724
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
5725
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
5726
|
+
query['InstanceId'] = request.instance_id
|
|
5727
|
+
req = open_api_models.OpenApiRequest(
|
|
5728
|
+
query=OpenApiUtilClient.query(query)
|
|
5729
|
+
)
|
|
5730
|
+
params = open_api_models.Params(
|
|
5731
|
+
action='DisableCustomPrivacyPolicy',
|
|
5732
|
+
version='2021-12-01',
|
|
5733
|
+
protocol='HTTPS',
|
|
5734
|
+
pathname='/',
|
|
5735
|
+
method='POST',
|
|
5736
|
+
auth_type='AK',
|
|
5737
|
+
style='RPC',
|
|
5738
|
+
req_body_type='formData',
|
|
5739
|
+
body_type='json'
|
|
5740
|
+
)
|
|
5741
|
+
return TeaCore.from_map(
|
|
5742
|
+
eiam_20211201_models.DisableCustomPrivacyPolicyResponse(),
|
|
5743
|
+
await self.call_api_async(params, req, runtime)
|
|
5744
|
+
)
|
|
5745
|
+
|
|
5746
|
+
def disable_custom_privacy_policy(
|
|
5747
|
+
self,
|
|
5748
|
+
request: eiam_20211201_models.DisableCustomPrivacyPolicyRequest,
|
|
5749
|
+
) -> eiam_20211201_models.DisableCustomPrivacyPolicyResponse:
|
|
5750
|
+
"""
|
|
5751
|
+
@summary 禁用自定义条款
|
|
5752
|
+
|
|
5753
|
+
@param request: DisableCustomPrivacyPolicyRequest
|
|
5754
|
+
@return: DisableCustomPrivacyPolicyResponse
|
|
5755
|
+
"""
|
|
5756
|
+
runtime = util_models.RuntimeOptions()
|
|
5757
|
+
return self.disable_custom_privacy_policy_with_options(request, runtime)
|
|
5758
|
+
|
|
5759
|
+
async def disable_custom_privacy_policy_async(
|
|
5760
|
+
self,
|
|
5761
|
+
request: eiam_20211201_models.DisableCustomPrivacyPolicyRequest,
|
|
5762
|
+
) -> eiam_20211201_models.DisableCustomPrivacyPolicyResponse:
|
|
5763
|
+
"""
|
|
5764
|
+
@summary 禁用自定义条款
|
|
5765
|
+
|
|
5766
|
+
@param request: DisableCustomPrivacyPolicyRequest
|
|
5767
|
+
@return: DisableCustomPrivacyPolicyResponse
|
|
5768
|
+
"""
|
|
5769
|
+
runtime = util_models.RuntimeOptions()
|
|
5770
|
+
return await self.disable_custom_privacy_policy_with_options_async(request, runtime)
|
|
5771
|
+
|
|
5240
5772
|
def disable_domain_proxy_token_with_options(
|
|
5241
5773
|
self,
|
|
5242
5774
|
request: eiam_20211201_models.DisableDomainProxyTokenRequest,
|
|
@@ -6757,6 +7289,106 @@ class Client(OpenApiClient):
|
|
|
6757
7289
|
runtime = util_models.RuntimeOptions()
|
|
6758
7290
|
return await self.enable_conditional_access_policy_with_options_async(request, runtime)
|
|
6759
7291
|
|
|
7292
|
+
def enable_custom_privacy_policy_with_options(
|
|
7293
|
+
self,
|
|
7294
|
+
request: eiam_20211201_models.EnableCustomPrivacyPolicyRequest,
|
|
7295
|
+
runtime: util_models.RuntimeOptions,
|
|
7296
|
+
) -> eiam_20211201_models.EnableCustomPrivacyPolicyResponse:
|
|
7297
|
+
"""
|
|
7298
|
+
@summary 启用自定义条款
|
|
7299
|
+
|
|
7300
|
+
@param request: EnableCustomPrivacyPolicyRequest
|
|
7301
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
7302
|
+
@return: EnableCustomPrivacyPolicyResponse
|
|
7303
|
+
"""
|
|
7304
|
+
UtilClient.validate_model(request)
|
|
7305
|
+
query = {}
|
|
7306
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
7307
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
7308
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
7309
|
+
query['InstanceId'] = request.instance_id
|
|
7310
|
+
req = open_api_models.OpenApiRequest(
|
|
7311
|
+
query=OpenApiUtilClient.query(query)
|
|
7312
|
+
)
|
|
7313
|
+
params = open_api_models.Params(
|
|
7314
|
+
action='EnableCustomPrivacyPolicy',
|
|
7315
|
+
version='2021-12-01',
|
|
7316
|
+
protocol='HTTPS',
|
|
7317
|
+
pathname='/',
|
|
7318
|
+
method='POST',
|
|
7319
|
+
auth_type='AK',
|
|
7320
|
+
style='RPC',
|
|
7321
|
+
req_body_type='formData',
|
|
7322
|
+
body_type='json'
|
|
7323
|
+
)
|
|
7324
|
+
return TeaCore.from_map(
|
|
7325
|
+
eiam_20211201_models.EnableCustomPrivacyPolicyResponse(),
|
|
7326
|
+
self.call_api(params, req, runtime)
|
|
7327
|
+
)
|
|
7328
|
+
|
|
7329
|
+
async def enable_custom_privacy_policy_with_options_async(
|
|
7330
|
+
self,
|
|
7331
|
+
request: eiam_20211201_models.EnableCustomPrivacyPolicyRequest,
|
|
7332
|
+
runtime: util_models.RuntimeOptions,
|
|
7333
|
+
) -> eiam_20211201_models.EnableCustomPrivacyPolicyResponse:
|
|
7334
|
+
"""
|
|
7335
|
+
@summary 启用自定义条款
|
|
7336
|
+
|
|
7337
|
+
@param request: EnableCustomPrivacyPolicyRequest
|
|
7338
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
7339
|
+
@return: EnableCustomPrivacyPolicyResponse
|
|
7340
|
+
"""
|
|
7341
|
+
UtilClient.validate_model(request)
|
|
7342
|
+
query = {}
|
|
7343
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
7344
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
7345
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
7346
|
+
query['InstanceId'] = request.instance_id
|
|
7347
|
+
req = open_api_models.OpenApiRequest(
|
|
7348
|
+
query=OpenApiUtilClient.query(query)
|
|
7349
|
+
)
|
|
7350
|
+
params = open_api_models.Params(
|
|
7351
|
+
action='EnableCustomPrivacyPolicy',
|
|
7352
|
+
version='2021-12-01',
|
|
7353
|
+
protocol='HTTPS',
|
|
7354
|
+
pathname='/',
|
|
7355
|
+
method='POST',
|
|
7356
|
+
auth_type='AK',
|
|
7357
|
+
style='RPC',
|
|
7358
|
+
req_body_type='formData',
|
|
7359
|
+
body_type='json'
|
|
7360
|
+
)
|
|
7361
|
+
return TeaCore.from_map(
|
|
7362
|
+
eiam_20211201_models.EnableCustomPrivacyPolicyResponse(),
|
|
7363
|
+
await self.call_api_async(params, req, runtime)
|
|
7364
|
+
)
|
|
7365
|
+
|
|
7366
|
+
def enable_custom_privacy_policy(
|
|
7367
|
+
self,
|
|
7368
|
+
request: eiam_20211201_models.EnableCustomPrivacyPolicyRequest,
|
|
7369
|
+
) -> eiam_20211201_models.EnableCustomPrivacyPolicyResponse:
|
|
7370
|
+
"""
|
|
7371
|
+
@summary 启用自定义条款
|
|
7372
|
+
|
|
7373
|
+
@param request: EnableCustomPrivacyPolicyRequest
|
|
7374
|
+
@return: EnableCustomPrivacyPolicyResponse
|
|
7375
|
+
"""
|
|
7376
|
+
runtime = util_models.RuntimeOptions()
|
|
7377
|
+
return self.enable_custom_privacy_policy_with_options(request, runtime)
|
|
7378
|
+
|
|
7379
|
+
async def enable_custom_privacy_policy_async(
|
|
7380
|
+
self,
|
|
7381
|
+
request: eiam_20211201_models.EnableCustomPrivacyPolicyRequest,
|
|
7382
|
+
) -> eiam_20211201_models.EnableCustomPrivacyPolicyResponse:
|
|
7383
|
+
"""
|
|
7384
|
+
@summary 启用自定义条款
|
|
7385
|
+
|
|
7386
|
+
@param request: EnableCustomPrivacyPolicyRequest
|
|
7387
|
+
@return: EnableCustomPrivacyPolicyResponse
|
|
7388
|
+
"""
|
|
7389
|
+
runtime = util_models.RuntimeOptions()
|
|
7390
|
+
return await self.enable_custom_privacy_policy_with_options_async(request, runtime)
|
|
7391
|
+
|
|
6760
7392
|
def enable_domain_proxy_token_with_options(
|
|
6761
7393
|
self,
|
|
6762
7394
|
request: eiam_20211201_models.EnableDomainProxyTokenRequest,
|
|
@@ -8265,29 +8897,29 @@ class Client(OpenApiClient):
|
|
|
8265
8897
|
runtime = util_models.RuntimeOptions()
|
|
8266
8898
|
return await self.get_conditional_access_policy_with_options_async(request, runtime)
|
|
8267
8899
|
|
|
8268
|
-
def
|
|
8900
|
+
def get_custom_privacy_policy_with_options(
|
|
8269
8901
|
self,
|
|
8270
|
-
request: eiam_20211201_models.
|
|
8902
|
+
request: eiam_20211201_models.GetCustomPrivacyPolicyRequest,
|
|
8271
8903
|
runtime: util_models.RuntimeOptions,
|
|
8272
|
-
) -> eiam_20211201_models.
|
|
8904
|
+
) -> eiam_20211201_models.GetCustomPrivacyPolicyResponse:
|
|
8273
8905
|
"""
|
|
8274
|
-
@summary
|
|
8906
|
+
@summary 获取自定义条款
|
|
8275
8907
|
|
|
8276
|
-
@param request:
|
|
8908
|
+
@param request: GetCustomPrivacyPolicyRequest
|
|
8277
8909
|
@param runtime: runtime options for this request RuntimeOptions
|
|
8278
|
-
@return:
|
|
8910
|
+
@return: GetCustomPrivacyPolicyResponse
|
|
8279
8911
|
"""
|
|
8280
8912
|
UtilClient.validate_model(request)
|
|
8281
8913
|
query = {}
|
|
8282
|
-
if not UtilClient.is_unset(request.
|
|
8283
|
-
query['
|
|
8914
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
8915
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
8284
8916
|
if not UtilClient.is_unset(request.instance_id):
|
|
8285
8917
|
query['InstanceId'] = request.instance_id
|
|
8286
8918
|
req = open_api_models.OpenApiRequest(
|
|
8287
8919
|
query=OpenApiUtilClient.query(query)
|
|
8288
8920
|
)
|
|
8289
8921
|
params = open_api_models.Params(
|
|
8290
|
-
action='
|
|
8922
|
+
action='GetCustomPrivacyPolicy',
|
|
8291
8923
|
version='2021-12-01',
|
|
8292
8924
|
protocol='HTTPS',
|
|
8293
8925
|
pathname='/',
|
|
@@ -8298,33 +8930,33 @@ class Client(OpenApiClient):
|
|
|
8298
8930
|
body_type='json'
|
|
8299
8931
|
)
|
|
8300
8932
|
return TeaCore.from_map(
|
|
8301
|
-
eiam_20211201_models.
|
|
8933
|
+
eiam_20211201_models.GetCustomPrivacyPolicyResponse(),
|
|
8302
8934
|
self.call_api(params, req, runtime)
|
|
8303
8935
|
)
|
|
8304
8936
|
|
|
8305
|
-
async def
|
|
8937
|
+
async def get_custom_privacy_policy_with_options_async(
|
|
8306
8938
|
self,
|
|
8307
|
-
request: eiam_20211201_models.
|
|
8939
|
+
request: eiam_20211201_models.GetCustomPrivacyPolicyRequest,
|
|
8308
8940
|
runtime: util_models.RuntimeOptions,
|
|
8309
|
-
) -> eiam_20211201_models.
|
|
8941
|
+
) -> eiam_20211201_models.GetCustomPrivacyPolicyResponse:
|
|
8310
8942
|
"""
|
|
8311
|
-
@summary
|
|
8943
|
+
@summary 获取自定义条款
|
|
8312
8944
|
|
|
8313
|
-
@param request:
|
|
8945
|
+
@param request: GetCustomPrivacyPolicyRequest
|
|
8314
8946
|
@param runtime: runtime options for this request RuntimeOptions
|
|
8315
|
-
@return:
|
|
8947
|
+
@return: GetCustomPrivacyPolicyResponse
|
|
8316
8948
|
"""
|
|
8317
8949
|
UtilClient.validate_model(request)
|
|
8318
8950
|
query = {}
|
|
8319
|
-
if not UtilClient.is_unset(request.
|
|
8320
|
-
query['
|
|
8951
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
8952
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
8321
8953
|
if not UtilClient.is_unset(request.instance_id):
|
|
8322
8954
|
query['InstanceId'] = request.instance_id
|
|
8323
8955
|
req = open_api_models.OpenApiRequest(
|
|
8324
8956
|
query=OpenApiUtilClient.query(query)
|
|
8325
8957
|
)
|
|
8326
8958
|
params = open_api_models.Params(
|
|
8327
|
-
action='
|
|
8959
|
+
action='GetCustomPrivacyPolicy',
|
|
8328
8960
|
version='2021-12-01',
|
|
8329
8961
|
protocol='HTTPS',
|
|
8330
8962
|
pathname='/',
|
|
@@ -8335,16 +8967,116 @@ class Client(OpenApiClient):
|
|
|
8335
8967
|
body_type='json'
|
|
8336
8968
|
)
|
|
8337
8969
|
return TeaCore.from_map(
|
|
8338
|
-
eiam_20211201_models.
|
|
8970
|
+
eiam_20211201_models.GetCustomPrivacyPolicyResponse(),
|
|
8339
8971
|
await self.call_api_async(params, req, runtime)
|
|
8340
8972
|
)
|
|
8341
8973
|
|
|
8342
|
-
def
|
|
8974
|
+
def get_custom_privacy_policy(
|
|
8343
8975
|
self,
|
|
8344
|
-
request: eiam_20211201_models.
|
|
8345
|
-
) -> eiam_20211201_models.
|
|
8976
|
+
request: eiam_20211201_models.GetCustomPrivacyPolicyRequest,
|
|
8977
|
+
) -> eiam_20211201_models.GetCustomPrivacyPolicyResponse:
|
|
8346
8978
|
"""
|
|
8347
|
-
@summary
|
|
8979
|
+
@summary 获取自定义条款
|
|
8980
|
+
|
|
8981
|
+
@param request: GetCustomPrivacyPolicyRequest
|
|
8982
|
+
@return: GetCustomPrivacyPolicyResponse
|
|
8983
|
+
"""
|
|
8984
|
+
runtime = util_models.RuntimeOptions()
|
|
8985
|
+
return self.get_custom_privacy_policy_with_options(request, runtime)
|
|
8986
|
+
|
|
8987
|
+
async def get_custom_privacy_policy_async(
|
|
8988
|
+
self,
|
|
8989
|
+
request: eiam_20211201_models.GetCustomPrivacyPolicyRequest,
|
|
8990
|
+
) -> eiam_20211201_models.GetCustomPrivacyPolicyResponse:
|
|
8991
|
+
"""
|
|
8992
|
+
@summary 获取自定义条款
|
|
8993
|
+
|
|
8994
|
+
@param request: GetCustomPrivacyPolicyRequest
|
|
8995
|
+
@return: GetCustomPrivacyPolicyResponse
|
|
8996
|
+
"""
|
|
8997
|
+
runtime = util_models.RuntimeOptions()
|
|
8998
|
+
return await self.get_custom_privacy_policy_with_options_async(request, runtime)
|
|
8999
|
+
|
|
9000
|
+
def get_domain_with_options(
|
|
9001
|
+
self,
|
|
9002
|
+
request: eiam_20211201_models.GetDomainRequest,
|
|
9003
|
+
runtime: util_models.RuntimeOptions,
|
|
9004
|
+
) -> eiam_20211201_models.GetDomainResponse:
|
|
9005
|
+
"""
|
|
9006
|
+
@summary Queries the information about a domain name of an Employee Identity and Access Management (EIAM) instance.
|
|
9007
|
+
|
|
9008
|
+
@param request: GetDomainRequest
|
|
9009
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
9010
|
+
@return: GetDomainResponse
|
|
9011
|
+
"""
|
|
9012
|
+
UtilClient.validate_model(request)
|
|
9013
|
+
query = {}
|
|
9014
|
+
if not UtilClient.is_unset(request.domain_id):
|
|
9015
|
+
query['DomainId'] = request.domain_id
|
|
9016
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
9017
|
+
query['InstanceId'] = request.instance_id
|
|
9018
|
+
req = open_api_models.OpenApiRequest(
|
|
9019
|
+
query=OpenApiUtilClient.query(query)
|
|
9020
|
+
)
|
|
9021
|
+
params = open_api_models.Params(
|
|
9022
|
+
action='GetDomain',
|
|
9023
|
+
version='2021-12-01',
|
|
9024
|
+
protocol='HTTPS',
|
|
9025
|
+
pathname='/',
|
|
9026
|
+
method='POST',
|
|
9027
|
+
auth_type='AK',
|
|
9028
|
+
style='RPC',
|
|
9029
|
+
req_body_type='formData',
|
|
9030
|
+
body_type='json'
|
|
9031
|
+
)
|
|
9032
|
+
return TeaCore.from_map(
|
|
9033
|
+
eiam_20211201_models.GetDomainResponse(),
|
|
9034
|
+
self.call_api(params, req, runtime)
|
|
9035
|
+
)
|
|
9036
|
+
|
|
9037
|
+
async def get_domain_with_options_async(
|
|
9038
|
+
self,
|
|
9039
|
+
request: eiam_20211201_models.GetDomainRequest,
|
|
9040
|
+
runtime: util_models.RuntimeOptions,
|
|
9041
|
+
) -> eiam_20211201_models.GetDomainResponse:
|
|
9042
|
+
"""
|
|
9043
|
+
@summary Queries the information about a domain name of an Employee Identity and Access Management (EIAM) instance.
|
|
9044
|
+
|
|
9045
|
+
@param request: GetDomainRequest
|
|
9046
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
9047
|
+
@return: GetDomainResponse
|
|
9048
|
+
"""
|
|
9049
|
+
UtilClient.validate_model(request)
|
|
9050
|
+
query = {}
|
|
9051
|
+
if not UtilClient.is_unset(request.domain_id):
|
|
9052
|
+
query['DomainId'] = request.domain_id
|
|
9053
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
9054
|
+
query['InstanceId'] = request.instance_id
|
|
9055
|
+
req = open_api_models.OpenApiRequest(
|
|
9056
|
+
query=OpenApiUtilClient.query(query)
|
|
9057
|
+
)
|
|
9058
|
+
params = open_api_models.Params(
|
|
9059
|
+
action='GetDomain',
|
|
9060
|
+
version='2021-12-01',
|
|
9061
|
+
protocol='HTTPS',
|
|
9062
|
+
pathname='/',
|
|
9063
|
+
method='POST',
|
|
9064
|
+
auth_type='AK',
|
|
9065
|
+
style='RPC',
|
|
9066
|
+
req_body_type='formData',
|
|
9067
|
+
body_type='json'
|
|
9068
|
+
)
|
|
9069
|
+
return TeaCore.from_map(
|
|
9070
|
+
eiam_20211201_models.GetDomainResponse(),
|
|
9071
|
+
await self.call_api_async(params, req, runtime)
|
|
9072
|
+
)
|
|
9073
|
+
|
|
9074
|
+
def get_domain(
|
|
9075
|
+
self,
|
|
9076
|
+
request: eiam_20211201_models.GetDomainRequest,
|
|
9077
|
+
) -> eiam_20211201_models.GetDomainResponse:
|
|
9078
|
+
"""
|
|
9079
|
+
@summary Queries the information about a domain name of an Employee Identity and Access Management (EIAM) instance.
|
|
8348
9080
|
|
|
8349
9081
|
@param request: GetDomainRequest
|
|
8350
9082
|
@return: GetDomainResponse
|
|
@@ -12217,6 +12949,230 @@ class Client(OpenApiClient):
|
|
|
12217
12949
|
runtime = util_models.RuntimeOptions()
|
|
12218
12950
|
return await self.list_conditional_access_policies_for_user_with_options_async(request, runtime)
|
|
12219
12951
|
|
|
12952
|
+
def list_custom_privacy_policies_with_options(
|
|
12953
|
+
self,
|
|
12954
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesRequest,
|
|
12955
|
+
runtime: util_models.RuntimeOptions,
|
|
12956
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesResponse:
|
|
12957
|
+
"""
|
|
12958
|
+
@summary 自定义条款列表查询。
|
|
12959
|
+
|
|
12960
|
+
@param request: ListCustomPrivacyPoliciesRequest
|
|
12961
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
12962
|
+
@return: ListCustomPrivacyPoliciesResponse
|
|
12963
|
+
"""
|
|
12964
|
+
UtilClient.validate_model(request)
|
|
12965
|
+
query = {}
|
|
12966
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name_starts_with):
|
|
12967
|
+
query['CustomPrivacyPolicyNameStartsWith'] = request.custom_privacy_policy_name_starts_with
|
|
12968
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
12969
|
+
query['InstanceId'] = request.instance_id
|
|
12970
|
+
if not UtilClient.is_unset(request.max_results):
|
|
12971
|
+
query['MaxResults'] = request.max_results
|
|
12972
|
+
if not UtilClient.is_unset(request.next_token):
|
|
12973
|
+
query['NextToken'] = request.next_token
|
|
12974
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
12975
|
+
query['PreviousToken'] = request.previous_token
|
|
12976
|
+
req = open_api_models.OpenApiRequest(
|
|
12977
|
+
query=OpenApiUtilClient.query(query)
|
|
12978
|
+
)
|
|
12979
|
+
params = open_api_models.Params(
|
|
12980
|
+
action='ListCustomPrivacyPolicies',
|
|
12981
|
+
version='2021-12-01',
|
|
12982
|
+
protocol='HTTPS',
|
|
12983
|
+
pathname='/',
|
|
12984
|
+
method='POST',
|
|
12985
|
+
auth_type='AK',
|
|
12986
|
+
style='RPC',
|
|
12987
|
+
req_body_type='formData',
|
|
12988
|
+
body_type='json'
|
|
12989
|
+
)
|
|
12990
|
+
return TeaCore.from_map(
|
|
12991
|
+
eiam_20211201_models.ListCustomPrivacyPoliciesResponse(),
|
|
12992
|
+
self.call_api(params, req, runtime)
|
|
12993
|
+
)
|
|
12994
|
+
|
|
12995
|
+
async def list_custom_privacy_policies_with_options_async(
|
|
12996
|
+
self,
|
|
12997
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesRequest,
|
|
12998
|
+
runtime: util_models.RuntimeOptions,
|
|
12999
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesResponse:
|
|
13000
|
+
"""
|
|
13001
|
+
@summary 自定义条款列表查询。
|
|
13002
|
+
|
|
13003
|
+
@param request: ListCustomPrivacyPoliciesRequest
|
|
13004
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
13005
|
+
@return: ListCustomPrivacyPoliciesResponse
|
|
13006
|
+
"""
|
|
13007
|
+
UtilClient.validate_model(request)
|
|
13008
|
+
query = {}
|
|
13009
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name_starts_with):
|
|
13010
|
+
query['CustomPrivacyPolicyNameStartsWith'] = request.custom_privacy_policy_name_starts_with
|
|
13011
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
13012
|
+
query['InstanceId'] = request.instance_id
|
|
13013
|
+
if not UtilClient.is_unset(request.max_results):
|
|
13014
|
+
query['MaxResults'] = request.max_results
|
|
13015
|
+
if not UtilClient.is_unset(request.next_token):
|
|
13016
|
+
query['NextToken'] = request.next_token
|
|
13017
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
13018
|
+
query['PreviousToken'] = request.previous_token
|
|
13019
|
+
req = open_api_models.OpenApiRequest(
|
|
13020
|
+
query=OpenApiUtilClient.query(query)
|
|
13021
|
+
)
|
|
13022
|
+
params = open_api_models.Params(
|
|
13023
|
+
action='ListCustomPrivacyPolicies',
|
|
13024
|
+
version='2021-12-01',
|
|
13025
|
+
protocol='HTTPS',
|
|
13026
|
+
pathname='/',
|
|
13027
|
+
method='POST',
|
|
13028
|
+
auth_type='AK',
|
|
13029
|
+
style='RPC',
|
|
13030
|
+
req_body_type='formData',
|
|
13031
|
+
body_type='json'
|
|
13032
|
+
)
|
|
13033
|
+
return TeaCore.from_map(
|
|
13034
|
+
eiam_20211201_models.ListCustomPrivacyPoliciesResponse(),
|
|
13035
|
+
await self.call_api_async(params, req, runtime)
|
|
13036
|
+
)
|
|
13037
|
+
|
|
13038
|
+
def list_custom_privacy_policies(
|
|
13039
|
+
self,
|
|
13040
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesRequest,
|
|
13041
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesResponse:
|
|
13042
|
+
"""
|
|
13043
|
+
@summary 自定义条款列表查询。
|
|
13044
|
+
|
|
13045
|
+
@param request: ListCustomPrivacyPoliciesRequest
|
|
13046
|
+
@return: ListCustomPrivacyPoliciesResponse
|
|
13047
|
+
"""
|
|
13048
|
+
runtime = util_models.RuntimeOptions()
|
|
13049
|
+
return self.list_custom_privacy_policies_with_options(request, runtime)
|
|
13050
|
+
|
|
13051
|
+
async def list_custom_privacy_policies_async(
|
|
13052
|
+
self,
|
|
13053
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesRequest,
|
|
13054
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesResponse:
|
|
13055
|
+
"""
|
|
13056
|
+
@summary 自定义条款列表查询。
|
|
13057
|
+
|
|
13058
|
+
@param request: ListCustomPrivacyPoliciesRequest
|
|
13059
|
+
@return: ListCustomPrivacyPoliciesResponse
|
|
13060
|
+
"""
|
|
13061
|
+
runtime = util_models.RuntimeOptions()
|
|
13062
|
+
return await self.list_custom_privacy_policies_with_options_async(request, runtime)
|
|
13063
|
+
|
|
13064
|
+
def list_custom_privacy_policies_for_brand_with_options(
|
|
13065
|
+
self,
|
|
13066
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesForBrandRequest,
|
|
13067
|
+
runtime: util_models.RuntimeOptions,
|
|
13068
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse:
|
|
13069
|
+
"""
|
|
13070
|
+
@summary 获取品牌关联资源的资源
|
|
13071
|
+
|
|
13072
|
+
@param request: ListCustomPrivacyPoliciesForBrandRequest
|
|
13073
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
13074
|
+
@return: ListCustomPrivacyPoliciesForBrandResponse
|
|
13075
|
+
"""
|
|
13076
|
+
UtilClient.validate_model(request)
|
|
13077
|
+
query = {}
|
|
13078
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
13079
|
+
query['BrandId'] = request.brand_id
|
|
13080
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
13081
|
+
query['InstanceId'] = request.instance_id
|
|
13082
|
+
if not UtilClient.is_unset(request.max_results):
|
|
13083
|
+
query['MaxResults'] = request.max_results
|
|
13084
|
+
if not UtilClient.is_unset(request.next_token):
|
|
13085
|
+
query['NextToken'] = request.next_token
|
|
13086
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
13087
|
+
query['PreviousToken'] = request.previous_token
|
|
13088
|
+
req = open_api_models.OpenApiRequest(
|
|
13089
|
+
query=OpenApiUtilClient.query(query)
|
|
13090
|
+
)
|
|
13091
|
+
params = open_api_models.Params(
|
|
13092
|
+
action='ListCustomPrivacyPoliciesForBrand',
|
|
13093
|
+
version='2021-12-01',
|
|
13094
|
+
protocol='HTTPS',
|
|
13095
|
+
pathname='/',
|
|
13096
|
+
method='POST',
|
|
13097
|
+
auth_type='AK',
|
|
13098
|
+
style='RPC',
|
|
13099
|
+
req_body_type='formData',
|
|
13100
|
+
body_type='json'
|
|
13101
|
+
)
|
|
13102
|
+
return TeaCore.from_map(
|
|
13103
|
+
eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse(),
|
|
13104
|
+
self.call_api(params, req, runtime)
|
|
13105
|
+
)
|
|
13106
|
+
|
|
13107
|
+
async def list_custom_privacy_policies_for_brand_with_options_async(
|
|
13108
|
+
self,
|
|
13109
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesForBrandRequest,
|
|
13110
|
+
runtime: util_models.RuntimeOptions,
|
|
13111
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse:
|
|
13112
|
+
"""
|
|
13113
|
+
@summary 获取品牌关联资源的资源
|
|
13114
|
+
|
|
13115
|
+
@param request: ListCustomPrivacyPoliciesForBrandRequest
|
|
13116
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
13117
|
+
@return: ListCustomPrivacyPoliciesForBrandResponse
|
|
13118
|
+
"""
|
|
13119
|
+
UtilClient.validate_model(request)
|
|
13120
|
+
query = {}
|
|
13121
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
13122
|
+
query['BrandId'] = request.brand_id
|
|
13123
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
13124
|
+
query['InstanceId'] = request.instance_id
|
|
13125
|
+
if not UtilClient.is_unset(request.max_results):
|
|
13126
|
+
query['MaxResults'] = request.max_results
|
|
13127
|
+
if not UtilClient.is_unset(request.next_token):
|
|
13128
|
+
query['NextToken'] = request.next_token
|
|
13129
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
13130
|
+
query['PreviousToken'] = request.previous_token
|
|
13131
|
+
req = open_api_models.OpenApiRequest(
|
|
13132
|
+
query=OpenApiUtilClient.query(query)
|
|
13133
|
+
)
|
|
13134
|
+
params = open_api_models.Params(
|
|
13135
|
+
action='ListCustomPrivacyPoliciesForBrand',
|
|
13136
|
+
version='2021-12-01',
|
|
13137
|
+
protocol='HTTPS',
|
|
13138
|
+
pathname='/',
|
|
13139
|
+
method='POST',
|
|
13140
|
+
auth_type='AK',
|
|
13141
|
+
style='RPC',
|
|
13142
|
+
req_body_type='formData',
|
|
13143
|
+
body_type='json'
|
|
13144
|
+
)
|
|
13145
|
+
return TeaCore.from_map(
|
|
13146
|
+
eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse(),
|
|
13147
|
+
await self.call_api_async(params, req, runtime)
|
|
13148
|
+
)
|
|
13149
|
+
|
|
13150
|
+
def list_custom_privacy_policies_for_brand(
|
|
13151
|
+
self,
|
|
13152
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesForBrandRequest,
|
|
13153
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse:
|
|
13154
|
+
"""
|
|
13155
|
+
@summary 获取品牌关联资源的资源
|
|
13156
|
+
|
|
13157
|
+
@param request: ListCustomPrivacyPoliciesForBrandRequest
|
|
13158
|
+
@return: ListCustomPrivacyPoliciesForBrandResponse
|
|
13159
|
+
"""
|
|
13160
|
+
runtime = util_models.RuntimeOptions()
|
|
13161
|
+
return self.list_custom_privacy_policies_for_brand_with_options(request, runtime)
|
|
13162
|
+
|
|
13163
|
+
async def list_custom_privacy_policies_for_brand_async(
|
|
13164
|
+
self,
|
|
13165
|
+
request: eiam_20211201_models.ListCustomPrivacyPoliciesForBrandRequest,
|
|
13166
|
+
) -> eiam_20211201_models.ListCustomPrivacyPoliciesForBrandResponse:
|
|
13167
|
+
"""
|
|
13168
|
+
@summary 获取品牌关联资源的资源
|
|
13169
|
+
|
|
13170
|
+
@param request: ListCustomPrivacyPoliciesForBrandRequest
|
|
13171
|
+
@return: ListCustomPrivacyPoliciesForBrandResponse
|
|
13172
|
+
"""
|
|
13173
|
+
runtime = util_models.RuntimeOptions()
|
|
13174
|
+
return await self.list_custom_privacy_policies_for_brand_with_options_async(request, runtime)
|
|
13175
|
+
|
|
12220
13176
|
def list_domain_proxy_tokens_with_options(
|
|
12221
13177
|
self,
|
|
12222
13178
|
request: eiam_20211201_models.ListDomainProxyTokensRequest,
|
|
@@ -14346,35 +15302,155 @@ class Client(OpenApiClient):
|
|
|
14346
15302
|
"""
|
|
14347
15303
|
UtilClient.validate_model(request)
|
|
14348
15304
|
query = {}
|
|
14349
|
-
if not UtilClient.is_unset(request.direction):
|
|
14350
|
-
query['Direction'] = request.direction
|
|
14351
|
-
if not UtilClient.is_unset(request.end_time):
|
|
14352
|
-
query['EndTime'] = request.end_time
|
|
14353
|
-
if not UtilClient.is_unset(request.filters):
|
|
14354
|
-
query['Filters'] = request.filters
|
|
15305
|
+
if not UtilClient.is_unset(request.direction):
|
|
15306
|
+
query['Direction'] = request.direction
|
|
15307
|
+
if not UtilClient.is_unset(request.end_time):
|
|
15308
|
+
query['EndTime'] = request.end_time
|
|
15309
|
+
if not UtilClient.is_unset(request.filters):
|
|
15310
|
+
query['Filters'] = request.filters
|
|
15311
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
15312
|
+
query['InstanceId'] = request.instance_id
|
|
15313
|
+
if not UtilClient.is_unset(request.max_results):
|
|
15314
|
+
query['MaxResults'] = request.max_results
|
|
15315
|
+
if not UtilClient.is_unset(request.next_token):
|
|
15316
|
+
query['NextToken'] = request.next_token
|
|
15317
|
+
if not UtilClient.is_unset(request.page_number):
|
|
15318
|
+
query['PageNumber'] = request.page_number
|
|
15319
|
+
if not UtilClient.is_unset(request.page_size):
|
|
15320
|
+
query['PageSize'] = request.page_size
|
|
15321
|
+
if not UtilClient.is_unset(request.start_time):
|
|
15322
|
+
query['StartTime'] = request.start_time
|
|
15323
|
+
if not UtilClient.is_unset(request.status):
|
|
15324
|
+
query['Status'] = request.status
|
|
15325
|
+
if not UtilClient.is_unset(request.target_ids):
|
|
15326
|
+
query['TargetIds'] = request.target_ids
|
|
15327
|
+
if not UtilClient.is_unset(request.target_type):
|
|
15328
|
+
query['TargetType'] = request.target_type
|
|
15329
|
+
req = open_api_models.OpenApiRequest(
|
|
15330
|
+
query=OpenApiUtilClient.query(query)
|
|
15331
|
+
)
|
|
15332
|
+
params = open_api_models.Params(
|
|
15333
|
+
action='ListSynchronizationJobs',
|
|
15334
|
+
version='2021-12-01',
|
|
15335
|
+
protocol='HTTPS',
|
|
15336
|
+
pathname='/',
|
|
15337
|
+
method='POST',
|
|
15338
|
+
auth_type='AK',
|
|
15339
|
+
style='RPC',
|
|
15340
|
+
req_body_type='formData',
|
|
15341
|
+
body_type='json'
|
|
15342
|
+
)
|
|
15343
|
+
return TeaCore.from_map(
|
|
15344
|
+
eiam_20211201_models.ListSynchronizationJobsResponse(),
|
|
15345
|
+
await self.call_api_async(params, req, runtime)
|
|
15346
|
+
)
|
|
15347
|
+
|
|
15348
|
+
def list_synchronization_jobs(
|
|
15349
|
+
self,
|
|
15350
|
+
request: eiam_20211201_models.ListSynchronizationJobsRequest,
|
|
15351
|
+
) -> eiam_20211201_models.ListSynchronizationJobsResponse:
|
|
15352
|
+
"""
|
|
15353
|
+
@summary 查询同步任务
|
|
15354
|
+
|
|
15355
|
+
@param request: ListSynchronizationJobsRequest
|
|
15356
|
+
@return: ListSynchronizationJobsResponse
|
|
15357
|
+
"""
|
|
15358
|
+
runtime = util_models.RuntimeOptions()
|
|
15359
|
+
return self.list_synchronization_jobs_with_options(request, runtime)
|
|
15360
|
+
|
|
15361
|
+
async def list_synchronization_jobs_async(
|
|
15362
|
+
self,
|
|
15363
|
+
request: eiam_20211201_models.ListSynchronizationJobsRequest,
|
|
15364
|
+
) -> eiam_20211201_models.ListSynchronizationJobsResponse:
|
|
15365
|
+
"""
|
|
15366
|
+
@summary 查询同步任务
|
|
15367
|
+
|
|
15368
|
+
@param request: ListSynchronizationJobsRequest
|
|
15369
|
+
@return: ListSynchronizationJobsResponse
|
|
15370
|
+
"""
|
|
15371
|
+
runtime = util_models.RuntimeOptions()
|
|
15372
|
+
return await self.list_synchronization_jobs_with_options_async(request, runtime)
|
|
15373
|
+
|
|
15374
|
+
def list_user_authn_source_mappings_with_options(
|
|
15375
|
+
self,
|
|
15376
|
+
request: eiam_20211201_models.ListUserAuthnSourceMappingsRequest,
|
|
15377
|
+
runtime: util_models.RuntimeOptions,
|
|
15378
|
+
) -> eiam_20211201_models.ListUserAuthnSourceMappingsResponse:
|
|
15379
|
+
"""
|
|
15380
|
+
@summary 查询三方登录账户绑定关系
|
|
15381
|
+
|
|
15382
|
+
@param request: ListUserAuthnSourceMappingsRequest
|
|
15383
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
15384
|
+
@return: ListUserAuthnSourceMappingsResponse
|
|
15385
|
+
"""
|
|
15386
|
+
UtilClient.validate_model(request)
|
|
15387
|
+
query = {}
|
|
15388
|
+
if not UtilClient.is_unset(request.identity_provider_id):
|
|
15389
|
+
query['IdentityProviderId'] = request.identity_provider_id
|
|
15390
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
15391
|
+
query['InstanceId'] = request.instance_id
|
|
15392
|
+
if not UtilClient.is_unset(request.max_results):
|
|
15393
|
+
query['MaxResults'] = request.max_results
|
|
15394
|
+
if not UtilClient.is_unset(request.next_token):
|
|
15395
|
+
query['NextToken'] = request.next_token
|
|
15396
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
15397
|
+
query['PreviousToken'] = request.previous_token
|
|
15398
|
+
if not UtilClient.is_unset(request.user_external_id):
|
|
15399
|
+
query['UserExternalId'] = request.user_external_id
|
|
15400
|
+
if not UtilClient.is_unset(request.user_id):
|
|
15401
|
+
query['UserId'] = request.user_id
|
|
15402
|
+
req = open_api_models.OpenApiRequest(
|
|
15403
|
+
query=OpenApiUtilClient.query(query)
|
|
15404
|
+
)
|
|
15405
|
+
params = open_api_models.Params(
|
|
15406
|
+
action='ListUserAuthnSourceMappings',
|
|
15407
|
+
version='2021-12-01',
|
|
15408
|
+
protocol='HTTPS',
|
|
15409
|
+
pathname='/',
|
|
15410
|
+
method='POST',
|
|
15411
|
+
auth_type='AK',
|
|
15412
|
+
style='RPC',
|
|
15413
|
+
req_body_type='formData',
|
|
15414
|
+
body_type='json'
|
|
15415
|
+
)
|
|
15416
|
+
return TeaCore.from_map(
|
|
15417
|
+
eiam_20211201_models.ListUserAuthnSourceMappingsResponse(),
|
|
15418
|
+
self.call_api(params, req, runtime)
|
|
15419
|
+
)
|
|
15420
|
+
|
|
15421
|
+
async def list_user_authn_source_mappings_with_options_async(
|
|
15422
|
+
self,
|
|
15423
|
+
request: eiam_20211201_models.ListUserAuthnSourceMappingsRequest,
|
|
15424
|
+
runtime: util_models.RuntimeOptions,
|
|
15425
|
+
) -> eiam_20211201_models.ListUserAuthnSourceMappingsResponse:
|
|
15426
|
+
"""
|
|
15427
|
+
@summary 查询三方登录账户绑定关系
|
|
15428
|
+
|
|
15429
|
+
@param request: ListUserAuthnSourceMappingsRequest
|
|
15430
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
15431
|
+
@return: ListUserAuthnSourceMappingsResponse
|
|
15432
|
+
"""
|
|
15433
|
+
UtilClient.validate_model(request)
|
|
15434
|
+
query = {}
|
|
15435
|
+
if not UtilClient.is_unset(request.identity_provider_id):
|
|
15436
|
+
query['IdentityProviderId'] = request.identity_provider_id
|
|
14355
15437
|
if not UtilClient.is_unset(request.instance_id):
|
|
14356
15438
|
query['InstanceId'] = request.instance_id
|
|
14357
15439
|
if not UtilClient.is_unset(request.max_results):
|
|
14358
15440
|
query['MaxResults'] = request.max_results
|
|
14359
15441
|
if not UtilClient.is_unset(request.next_token):
|
|
14360
15442
|
query['NextToken'] = request.next_token
|
|
14361
|
-
if not UtilClient.is_unset(request.
|
|
14362
|
-
query['
|
|
14363
|
-
if not UtilClient.is_unset(request.
|
|
14364
|
-
query['
|
|
14365
|
-
if not UtilClient.is_unset(request.
|
|
14366
|
-
query['
|
|
14367
|
-
if not UtilClient.is_unset(request.status):
|
|
14368
|
-
query['Status'] = request.status
|
|
14369
|
-
if not UtilClient.is_unset(request.target_ids):
|
|
14370
|
-
query['TargetIds'] = request.target_ids
|
|
14371
|
-
if not UtilClient.is_unset(request.target_type):
|
|
14372
|
-
query['TargetType'] = request.target_type
|
|
15443
|
+
if not UtilClient.is_unset(request.previous_token):
|
|
15444
|
+
query['PreviousToken'] = request.previous_token
|
|
15445
|
+
if not UtilClient.is_unset(request.user_external_id):
|
|
15446
|
+
query['UserExternalId'] = request.user_external_id
|
|
15447
|
+
if not UtilClient.is_unset(request.user_id):
|
|
15448
|
+
query['UserId'] = request.user_id
|
|
14373
15449
|
req = open_api_models.OpenApiRequest(
|
|
14374
15450
|
query=OpenApiUtilClient.query(query)
|
|
14375
15451
|
)
|
|
14376
15452
|
params = open_api_models.Params(
|
|
14377
|
-
action='
|
|
15453
|
+
action='ListUserAuthnSourceMappings',
|
|
14378
15454
|
version='2021-12-01',
|
|
14379
15455
|
protocol='HTTPS',
|
|
14380
15456
|
pathname='/',
|
|
@@ -14385,35 +15461,35 @@ class Client(OpenApiClient):
|
|
|
14385
15461
|
body_type='json'
|
|
14386
15462
|
)
|
|
14387
15463
|
return TeaCore.from_map(
|
|
14388
|
-
eiam_20211201_models.
|
|
15464
|
+
eiam_20211201_models.ListUserAuthnSourceMappingsResponse(),
|
|
14389
15465
|
await self.call_api_async(params, req, runtime)
|
|
14390
15466
|
)
|
|
14391
15467
|
|
|
14392
|
-
def
|
|
15468
|
+
def list_user_authn_source_mappings(
|
|
14393
15469
|
self,
|
|
14394
|
-
request: eiam_20211201_models.
|
|
14395
|
-
) -> eiam_20211201_models.
|
|
15470
|
+
request: eiam_20211201_models.ListUserAuthnSourceMappingsRequest,
|
|
15471
|
+
) -> eiam_20211201_models.ListUserAuthnSourceMappingsResponse:
|
|
14396
15472
|
"""
|
|
14397
|
-
@summary
|
|
15473
|
+
@summary 查询三方登录账户绑定关系
|
|
14398
15474
|
|
|
14399
|
-
@param request:
|
|
14400
|
-
@return:
|
|
15475
|
+
@param request: ListUserAuthnSourceMappingsRequest
|
|
15476
|
+
@return: ListUserAuthnSourceMappingsResponse
|
|
14401
15477
|
"""
|
|
14402
15478
|
runtime = util_models.RuntimeOptions()
|
|
14403
|
-
return self.
|
|
15479
|
+
return self.list_user_authn_source_mappings_with_options(request, runtime)
|
|
14404
15480
|
|
|
14405
|
-
async def
|
|
15481
|
+
async def list_user_authn_source_mappings_async(
|
|
14406
15482
|
self,
|
|
14407
|
-
request: eiam_20211201_models.
|
|
14408
|
-
) -> eiam_20211201_models.
|
|
15483
|
+
request: eiam_20211201_models.ListUserAuthnSourceMappingsRequest,
|
|
15484
|
+
) -> eiam_20211201_models.ListUserAuthnSourceMappingsResponse:
|
|
14409
15485
|
"""
|
|
14410
|
-
@summary
|
|
15486
|
+
@summary 查询三方登录账户绑定关系
|
|
14411
15487
|
|
|
14412
|
-
@param request:
|
|
14413
|
-
@return:
|
|
15488
|
+
@param request: ListUserAuthnSourceMappingsRequest
|
|
15489
|
+
@return: ListUserAuthnSourceMappingsResponse
|
|
14414
15490
|
"""
|
|
14415
15491
|
runtime = util_models.RuntimeOptions()
|
|
14416
|
-
return await self.
|
|
15492
|
+
return await self.list_user_authn_source_mappings_with_options_async(request, runtime)
|
|
14417
15493
|
|
|
14418
15494
|
def list_users_with_options(
|
|
14419
15495
|
self,
|
|
@@ -15207,6 +16283,110 @@ class Client(OpenApiClient):
|
|
|
15207
16283
|
runtime = util_models.RuntimeOptions()
|
|
15208
16284
|
return await self.remove_application_account_from_user_with_options_async(request, runtime)
|
|
15209
16285
|
|
|
16286
|
+
def remove_custom_privacy_policies_from_brand_with_options(
|
|
16287
|
+
self,
|
|
16288
|
+
request: eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandRequest,
|
|
16289
|
+
runtime: util_models.RuntimeOptions,
|
|
16290
|
+
) -> eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse:
|
|
16291
|
+
"""
|
|
16292
|
+
@summary 移除品牌关联条款
|
|
16293
|
+
|
|
16294
|
+
@param request: RemoveCustomPrivacyPoliciesFromBrandRequest
|
|
16295
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
16296
|
+
@return: RemoveCustomPrivacyPoliciesFromBrandResponse
|
|
16297
|
+
"""
|
|
16298
|
+
UtilClient.validate_model(request)
|
|
16299
|
+
query = {}
|
|
16300
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
16301
|
+
query['BrandId'] = request.brand_id
|
|
16302
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_ids):
|
|
16303
|
+
query['CustomPrivacyPolicyIds'] = request.custom_privacy_policy_ids
|
|
16304
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
16305
|
+
query['InstanceId'] = request.instance_id
|
|
16306
|
+
req = open_api_models.OpenApiRequest(
|
|
16307
|
+
query=OpenApiUtilClient.query(query)
|
|
16308
|
+
)
|
|
16309
|
+
params = open_api_models.Params(
|
|
16310
|
+
action='RemoveCustomPrivacyPoliciesFromBrand',
|
|
16311
|
+
version='2021-12-01',
|
|
16312
|
+
protocol='HTTPS',
|
|
16313
|
+
pathname='/',
|
|
16314
|
+
method='POST',
|
|
16315
|
+
auth_type='AK',
|
|
16316
|
+
style='RPC',
|
|
16317
|
+
req_body_type='formData',
|
|
16318
|
+
body_type='json'
|
|
16319
|
+
)
|
|
16320
|
+
return TeaCore.from_map(
|
|
16321
|
+
eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse(),
|
|
16322
|
+
self.call_api(params, req, runtime)
|
|
16323
|
+
)
|
|
16324
|
+
|
|
16325
|
+
async def remove_custom_privacy_policies_from_brand_with_options_async(
|
|
16326
|
+
self,
|
|
16327
|
+
request: eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandRequest,
|
|
16328
|
+
runtime: util_models.RuntimeOptions,
|
|
16329
|
+
) -> eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse:
|
|
16330
|
+
"""
|
|
16331
|
+
@summary 移除品牌关联条款
|
|
16332
|
+
|
|
16333
|
+
@param request: RemoveCustomPrivacyPoliciesFromBrandRequest
|
|
16334
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
16335
|
+
@return: RemoveCustomPrivacyPoliciesFromBrandResponse
|
|
16336
|
+
"""
|
|
16337
|
+
UtilClient.validate_model(request)
|
|
16338
|
+
query = {}
|
|
16339
|
+
if not UtilClient.is_unset(request.brand_id):
|
|
16340
|
+
query['BrandId'] = request.brand_id
|
|
16341
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_ids):
|
|
16342
|
+
query['CustomPrivacyPolicyIds'] = request.custom_privacy_policy_ids
|
|
16343
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
16344
|
+
query['InstanceId'] = request.instance_id
|
|
16345
|
+
req = open_api_models.OpenApiRequest(
|
|
16346
|
+
query=OpenApiUtilClient.query(query)
|
|
16347
|
+
)
|
|
16348
|
+
params = open_api_models.Params(
|
|
16349
|
+
action='RemoveCustomPrivacyPoliciesFromBrand',
|
|
16350
|
+
version='2021-12-01',
|
|
16351
|
+
protocol='HTTPS',
|
|
16352
|
+
pathname='/',
|
|
16353
|
+
method='POST',
|
|
16354
|
+
auth_type='AK',
|
|
16355
|
+
style='RPC',
|
|
16356
|
+
req_body_type='formData',
|
|
16357
|
+
body_type='json'
|
|
16358
|
+
)
|
|
16359
|
+
return TeaCore.from_map(
|
|
16360
|
+
eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse(),
|
|
16361
|
+
await self.call_api_async(params, req, runtime)
|
|
16362
|
+
)
|
|
16363
|
+
|
|
16364
|
+
def remove_custom_privacy_policies_from_brand(
|
|
16365
|
+
self,
|
|
16366
|
+
request: eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandRequest,
|
|
16367
|
+
) -> eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse:
|
|
16368
|
+
"""
|
|
16369
|
+
@summary 移除品牌关联条款
|
|
16370
|
+
|
|
16371
|
+
@param request: RemoveCustomPrivacyPoliciesFromBrandRequest
|
|
16372
|
+
@return: RemoveCustomPrivacyPoliciesFromBrandResponse
|
|
16373
|
+
"""
|
|
16374
|
+
runtime = util_models.RuntimeOptions()
|
|
16375
|
+
return self.remove_custom_privacy_policies_from_brand_with_options(request, runtime)
|
|
16376
|
+
|
|
16377
|
+
async def remove_custom_privacy_policies_from_brand_async(
|
|
16378
|
+
self,
|
|
16379
|
+
request: eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandRequest,
|
|
16380
|
+
) -> eiam_20211201_models.RemoveCustomPrivacyPoliciesFromBrandResponse:
|
|
16381
|
+
"""
|
|
16382
|
+
@summary 移除品牌关联条款
|
|
16383
|
+
|
|
16384
|
+
@param request: RemoveCustomPrivacyPoliciesFromBrandRequest
|
|
16385
|
+
@return: RemoveCustomPrivacyPoliciesFromBrandResponse
|
|
16386
|
+
"""
|
|
16387
|
+
runtime = util_models.RuntimeOptions()
|
|
16388
|
+
return await self.remove_custom_privacy_policies_from_brand_with_options_async(request, runtime)
|
|
16389
|
+
|
|
15210
16390
|
def remove_user_from_organizational_units_with_options(
|
|
15211
16391
|
self,
|
|
15212
16392
|
request: eiam_20211201_models.RemoveUserFromOrganizationalUnitsRequest,
|
|
@@ -17295,6 +18475,114 @@ class Client(OpenApiClient):
|
|
|
17295
18475
|
runtime = util_models.RuntimeOptions()
|
|
17296
18476
|
return await self.set_user_primary_organizational_unit_with_options_async(request, runtime)
|
|
17297
18477
|
|
|
18478
|
+
def unbind_user_authn_source_mapping_with_options(
|
|
18479
|
+
self,
|
|
18480
|
+
request: eiam_20211201_models.UnbindUserAuthnSourceMappingRequest,
|
|
18481
|
+
runtime: util_models.RuntimeOptions,
|
|
18482
|
+
) -> eiam_20211201_models.UnbindUserAuthnSourceMappingResponse:
|
|
18483
|
+
"""
|
|
18484
|
+
@summary 解绑三方登录账户
|
|
18485
|
+
|
|
18486
|
+
@param request: UnbindUserAuthnSourceMappingRequest
|
|
18487
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
18488
|
+
@return: UnbindUserAuthnSourceMappingResponse
|
|
18489
|
+
"""
|
|
18490
|
+
UtilClient.validate_model(request)
|
|
18491
|
+
query = {}
|
|
18492
|
+
if not UtilClient.is_unset(request.identity_provider_id):
|
|
18493
|
+
query['IdentityProviderId'] = request.identity_provider_id
|
|
18494
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
18495
|
+
query['InstanceId'] = request.instance_id
|
|
18496
|
+
if not UtilClient.is_unset(request.user_external_id):
|
|
18497
|
+
query['UserExternalId'] = request.user_external_id
|
|
18498
|
+
if not UtilClient.is_unset(request.user_id):
|
|
18499
|
+
query['UserId'] = request.user_id
|
|
18500
|
+
req = open_api_models.OpenApiRequest(
|
|
18501
|
+
query=OpenApiUtilClient.query(query)
|
|
18502
|
+
)
|
|
18503
|
+
params = open_api_models.Params(
|
|
18504
|
+
action='UnbindUserAuthnSourceMapping',
|
|
18505
|
+
version='2021-12-01',
|
|
18506
|
+
protocol='HTTPS',
|
|
18507
|
+
pathname='/',
|
|
18508
|
+
method='POST',
|
|
18509
|
+
auth_type='AK',
|
|
18510
|
+
style='RPC',
|
|
18511
|
+
req_body_type='formData',
|
|
18512
|
+
body_type='json'
|
|
18513
|
+
)
|
|
18514
|
+
return TeaCore.from_map(
|
|
18515
|
+
eiam_20211201_models.UnbindUserAuthnSourceMappingResponse(),
|
|
18516
|
+
self.call_api(params, req, runtime)
|
|
18517
|
+
)
|
|
18518
|
+
|
|
18519
|
+
async def unbind_user_authn_source_mapping_with_options_async(
|
|
18520
|
+
self,
|
|
18521
|
+
request: eiam_20211201_models.UnbindUserAuthnSourceMappingRequest,
|
|
18522
|
+
runtime: util_models.RuntimeOptions,
|
|
18523
|
+
) -> eiam_20211201_models.UnbindUserAuthnSourceMappingResponse:
|
|
18524
|
+
"""
|
|
18525
|
+
@summary 解绑三方登录账户
|
|
18526
|
+
|
|
18527
|
+
@param request: UnbindUserAuthnSourceMappingRequest
|
|
18528
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
18529
|
+
@return: UnbindUserAuthnSourceMappingResponse
|
|
18530
|
+
"""
|
|
18531
|
+
UtilClient.validate_model(request)
|
|
18532
|
+
query = {}
|
|
18533
|
+
if not UtilClient.is_unset(request.identity_provider_id):
|
|
18534
|
+
query['IdentityProviderId'] = request.identity_provider_id
|
|
18535
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
18536
|
+
query['InstanceId'] = request.instance_id
|
|
18537
|
+
if not UtilClient.is_unset(request.user_external_id):
|
|
18538
|
+
query['UserExternalId'] = request.user_external_id
|
|
18539
|
+
if not UtilClient.is_unset(request.user_id):
|
|
18540
|
+
query['UserId'] = request.user_id
|
|
18541
|
+
req = open_api_models.OpenApiRequest(
|
|
18542
|
+
query=OpenApiUtilClient.query(query)
|
|
18543
|
+
)
|
|
18544
|
+
params = open_api_models.Params(
|
|
18545
|
+
action='UnbindUserAuthnSourceMapping',
|
|
18546
|
+
version='2021-12-01',
|
|
18547
|
+
protocol='HTTPS',
|
|
18548
|
+
pathname='/',
|
|
18549
|
+
method='POST',
|
|
18550
|
+
auth_type='AK',
|
|
18551
|
+
style='RPC',
|
|
18552
|
+
req_body_type='formData',
|
|
18553
|
+
body_type='json'
|
|
18554
|
+
)
|
|
18555
|
+
return TeaCore.from_map(
|
|
18556
|
+
eiam_20211201_models.UnbindUserAuthnSourceMappingResponse(),
|
|
18557
|
+
await self.call_api_async(params, req, runtime)
|
|
18558
|
+
)
|
|
18559
|
+
|
|
18560
|
+
def unbind_user_authn_source_mapping(
|
|
18561
|
+
self,
|
|
18562
|
+
request: eiam_20211201_models.UnbindUserAuthnSourceMappingRequest,
|
|
18563
|
+
) -> eiam_20211201_models.UnbindUserAuthnSourceMappingResponse:
|
|
18564
|
+
"""
|
|
18565
|
+
@summary 解绑三方登录账户
|
|
18566
|
+
|
|
18567
|
+
@param request: UnbindUserAuthnSourceMappingRequest
|
|
18568
|
+
@return: UnbindUserAuthnSourceMappingResponse
|
|
18569
|
+
"""
|
|
18570
|
+
runtime = util_models.RuntimeOptions()
|
|
18571
|
+
return self.unbind_user_authn_source_mapping_with_options(request, runtime)
|
|
18572
|
+
|
|
18573
|
+
async def unbind_user_authn_source_mapping_async(
|
|
18574
|
+
self,
|
|
18575
|
+
request: eiam_20211201_models.UnbindUserAuthnSourceMappingRequest,
|
|
18576
|
+
) -> eiam_20211201_models.UnbindUserAuthnSourceMappingResponse:
|
|
18577
|
+
"""
|
|
18578
|
+
@summary 解绑三方登录账户
|
|
18579
|
+
|
|
18580
|
+
@param request: UnbindUserAuthnSourceMappingRequest
|
|
18581
|
+
@return: UnbindUserAuthnSourceMappingResponse
|
|
18582
|
+
"""
|
|
18583
|
+
runtime = util_models.RuntimeOptions()
|
|
18584
|
+
return await self.unbind_user_authn_source_mapping_with_options_async(request, runtime)
|
|
18585
|
+
|
|
17298
18586
|
def unlock_user_with_options(
|
|
17299
18587
|
self,
|
|
17300
18588
|
request: eiam_20211201_models.UnlockUserRequest,
|
|
@@ -18507,6 +19795,122 @@ class Client(OpenApiClient):
|
|
|
18507
19795
|
runtime = util_models.RuntimeOptions()
|
|
18508
19796
|
return await self.update_conditional_access_policy_description_with_options_async(request, runtime)
|
|
18509
19797
|
|
|
19798
|
+
def update_custom_privacy_policy_with_options(
|
|
19799
|
+
self,
|
|
19800
|
+
request: eiam_20211201_models.UpdateCustomPrivacyPolicyRequest,
|
|
19801
|
+
runtime: util_models.RuntimeOptions,
|
|
19802
|
+
) -> eiam_20211201_models.UpdateCustomPrivacyPolicyResponse:
|
|
19803
|
+
"""
|
|
19804
|
+
@summary 更新自定义条款
|
|
19805
|
+
|
|
19806
|
+
@param request: UpdateCustomPrivacyPolicyRequest
|
|
19807
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
19808
|
+
@return: UpdateCustomPrivacyPolicyResponse
|
|
19809
|
+
"""
|
|
19810
|
+
UtilClient.validate_model(request)
|
|
19811
|
+
query = {}
|
|
19812
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_contents):
|
|
19813
|
+
query['CustomPrivacyPolicyContents'] = request.custom_privacy_policy_contents
|
|
19814
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
19815
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
19816
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name):
|
|
19817
|
+
query['CustomPrivacyPolicyName'] = request.custom_privacy_policy_name
|
|
19818
|
+
if not UtilClient.is_unset(request.default_language_code):
|
|
19819
|
+
query['DefaultLanguageCode'] = request.default_language_code
|
|
19820
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
19821
|
+
query['InstanceId'] = request.instance_id
|
|
19822
|
+
if not UtilClient.is_unset(request.user_consent_type):
|
|
19823
|
+
query['UserConsentType'] = request.user_consent_type
|
|
19824
|
+
req = open_api_models.OpenApiRequest(
|
|
19825
|
+
query=OpenApiUtilClient.query(query)
|
|
19826
|
+
)
|
|
19827
|
+
params = open_api_models.Params(
|
|
19828
|
+
action='UpdateCustomPrivacyPolicy',
|
|
19829
|
+
version='2021-12-01',
|
|
19830
|
+
protocol='HTTPS',
|
|
19831
|
+
pathname='/',
|
|
19832
|
+
method='POST',
|
|
19833
|
+
auth_type='AK',
|
|
19834
|
+
style='RPC',
|
|
19835
|
+
req_body_type='formData',
|
|
19836
|
+
body_type='json'
|
|
19837
|
+
)
|
|
19838
|
+
return TeaCore.from_map(
|
|
19839
|
+
eiam_20211201_models.UpdateCustomPrivacyPolicyResponse(),
|
|
19840
|
+
self.call_api(params, req, runtime)
|
|
19841
|
+
)
|
|
19842
|
+
|
|
19843
|
+
async def update_custom_privacy_policy_with_options_async(
|
|
19844
|
+
self,
|
|
19845
|
+
request: eiam_20211201_models.UpdateCustomPrivacyPolicyRequest,
|
|
19846
|
+
runtime: util_models.RuntimeOptions,
|
|
19847
|
+
) -> eiam_20211201_models.UpdateCustomPrivacyPolicyResponse:
|
|
19848
|
+
"""
|
|
19849
|
+
@summary 更新自定义条款
|
|
19850
|
+
|
|
19851
|
+
@param request: UpdateCustomPrivacyPolicyRequest
|
|
19852
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
19853
|
+
@return: UpdateCustomPrivacyPolicyResponse
|
|
19854
|
+
"""
|
|
19855
|
+
UtilClient.validate_model(request)
|
|
19856
|
+
query = {}
|
|
19857
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_contents):
|
|
19858
|
+
query['CustomPrivacyPolicyContents'] = request.custom_privacy_policy_contents
|
|
19859
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_id):
|
|
19860
|
+
query['CustomPrivacyPolicyId'] = request.custom_privacy_policy_id
|
|
19861
|
+
if not UtilClient.is_unset(request.custom_privacy_policy_name):
|
|
19862
|
+
query['CustomPrivacyPolicyName'] = request.custom_privacy_policy_name
|
|
19863
|
+
if not UtilClient.is_unset(request.default_language_code):
|
|
19864
|
+
query['DefaultLanguageCode'] = request.default_language_code
|
|
19865
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
19866
|
+
query['InstanceId'] = request.instance_id
|
|
19867
|
+
if not UtilClient.is_unset(request.user_consent_type):
|
|
19868
|
+
query['UserConsentType'] = request.user_consent_type
|
|
19869
|
+
req = open_api_models.OpenApiRequest(
|
|
19870
|
+
query=OpenApiUtilClient.query(query)
|
|
19871
|
+
)
|
|
19872
|
+
params = open_api_models.Params(
|
|
19873
|
+
action='UpdateCustomPrivacyPolicy',
|
|
19874
|
+
version='2021-12-01',
|
|
19875
|
+
protocol='HTTPS',
|
|
19876
|
+
pathname='/',
|
|
19877
|
+
method='POST',
|
|
19878
|
+
auth_type='AK',
|
|
19879
|
+
style='RPC',
|
|
19880
|
+
req_body_type='formData',
|
|
19881
|
+
body_type='json'
|
|
19882
|
+
)
|
|
19883
|
+
return TeaCore.from_map(
|
|
19884
|
+
eiam_20211201_models.UpdateCustomPrivacyPolicyResponse(),
|
|
19885
|
+
await self.call_api_async(params, req, runtime)
|
|
19886
|
+
)
|
|
19887
|
+
|
|
19888
|
+
def update_custom_privacy_policy(
|
|
19889
|
+
self,
|
|
19890
|
+
request: eiam_20211201_models.UpdateCustomPrivacyPolicyRequest,
|
|
19891
|
+
) -> eiam_20211201_models.UpdateCustomPrivacyPolicyResponse:
|
|
19892
|
+
"""
|
|
19893
|
+
@summary 更新自定义条款
|
|
19894
|
+
|
|
19895
|
+
@param request: UpdateCustomPrivacyPolicyRequest
|
|
19896
|
+
@return: UpdateCustomPrivacyPolicyResponse
|
|
19897
|
+
"""
|
|
19898
|
+
runtime = util_models.RuntimeOptions()
|
|
19899
|
+
return self.update_custom_privacy_policy_with_options(request, runtime)
|
|
19900
|
+
|
|
19901
|
+
async def update_custom_privacy_policy_async(
|
|
19902
|
+
self,
|
|
19903
|
+
request: eiam_20211201_models.UpdateCustomPrivacyPolicyRequest,
|
|
19904
|
+
) -> eiam_20211201_models.UpdateCustomPrivacyPolicyResponse:
|
|
19905
|
+
"""
|
|
19906
|
+
@summary 更新自定义条款
|
|
19907
|
+
|
|
19908
|
+
@param request: UpdateCustomPrivacyPolicyRequest
|
|
19909
|
+
@return: UpdateCustomPrivacyPolicyResponse
|
|
19910
|
+
"""
|
|
19911
|
+
runtime = util_models.RuntimeOptions()
|
|
19912
|
+
return await self.update_custom_privacy_policy_with_options_async(request, runtime)
|
|
19913
|
+
|
|
18510
19914
|
def update_domain_brand_with_options(
|
|
18511
19915
|
self,
|
|
18512
19916
|
request: eiam_20211201_models.UpdateDomainBrandRequest,
|