resourcemanager-20161111/alibabacloud_resourcemanager20161111/models.py (6,992 lines of code) (raw):
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
class AttachPolicyRequest(TeaModel):
def __init__(self, account_id=None, policy_name=None, policy_type=None, principal_name=None,
principal_type=None, resource_group_id=None):
self.account_id = account_id # type: str
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
self.principal_name = principal_name # type: str
self.principal_type = principal_type # type: str
self.resource_group_id = resource_group_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(AttachPolicyRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
if self.principal_name is not None:
result['PrincipalName'] = self.principal_name
if self.principal_type is not None:
result['PrincipalType'] = self.principal_type
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
if m.get('PrincipalName') is not None:
self.principal_name = m.get('PrincipalName')
if m.get('PrincipalType') is not None:
self.principal_type = m.get('PrincipalType')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
return self
class AttachPolicyResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(AttachPolicyResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AttachPolicyResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: AttachPolicyResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(AttachPolicyResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AttachPolicyResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CancelCreateCloudAccountRequest(TeaModel):
def __init__(self, record_id=None):
self.record_id = record_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CancelCreateCloudAccountRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.record_id is not None:
result['RecordId'] = self.record_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
return self
class CancelCreateCloudAccountResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CancelCreateCloudAccountResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CancelCreateCloudAccountResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CancelCreateCloudAccountResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CancelCreateCloudAccountResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CancelCreateCloudAccountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CancelPromoteResourceAccountRequest(TeaModel):
def __init__(self, record_id=None):
self.record_id = record_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CancelPromoteResourceAccountRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.record_id is not None:
result['RecordId'] = self.record_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
return self
class CancelPromoteResourceAccountResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CancelPromoteResourceAccountResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CancelPromoteResourceAccountResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CancelPromoteResourceAccountResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CancelPromoteResourceAccountResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CancelPromoteResourceAccountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateCloudAccountRequest(TeaModel):
def __init__(self, display_name=None, email=None, enable_consolidated_billing=None, parent_folder_id=None,
payer_account_id=None):
self.display_name = display_name # type: str
self.email = email # type: str
self.enable_consolidated_billing = enable_consolidated_billing # type: bool
self.parent_folder_id = parent_folder_id # type: str
self.payer_account_id = payer_account_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateCloudAccountRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.email is not None:
result['Email'] = self.email
if self.enable_consolidated_billing is not None:
result['EnableConsolidatedBilling'] = self.enable_consolidated_billing
if self.parent_folder_id is not None:
result['ParentFolderId'] = self.parent_folder_id
if self.payer_account_id is not None:
result['PayerAccountId'] = self.payer_account_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('Email') is not None:
self.email = m.get('Email')
if m.get('EnableConsolidatedBilling') is not None:
self.enable_consolidated_billing = m.get('EnableConsolidatedBilling')
if m.get('ParentFolderId') is not None:
self.parent_folder_id = m.get('ParentFolderId')
if m.get('PayerAccountId') is not None:
self.payer_account_id = m.get('PayerAccountId')
return self
class CreateCloudAccountResponseBodyAccount(TeaModel):
def __init__(self, account_id=None, account_name=None, display_name=None, folder_id=None, join_method=None,
join_time=None, modify_time=None, record_id=None, resource_directory_id=None, status=None, type=None):
self.account_id = account_id # type: str
self.account_name = account_name # type: str
self.display_name = display_name # type: str
self.folder_id = folder_id # type: str
self.join_method = join_method # type: str
self.join_time = join_time # type: str
self.modify_time = modify_time # type: str
self.record_id = record_id # type: str
self.resource_directory_id = resource_directory_id # type: str
self.status = status # type: str
self.type = type # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateCloudAccountResponseBodyAccount, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.account_name is not None:
result['AccountName'] = self.account_name
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.join_method is not None:
result['JoinMethod'] = self.join_method
if self.join_time is not None:
result['JoinTime'] = self.join_time
if self.modify_time is not None:
result['ModifyTime'] = self.modify_time
if self.record_id is not None:
result['RecordId'] = self.record_id
if self.resource_directory_id is not None:
result['ResourceDirectoryId'] = self.resource_directory_id
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('AccountName') is not None:
self.account_name = m.get('AccountName')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('JoinMethod') is not None:
self.join_method = m.get('JoinMethod')
if m.get('JoinTime') is not None:
self.join_time = m.get('JoinTime')
if m.get('ModifyTime') is not None:
self.modify_time = m.get('ModifyTime')
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
if m.get('ResourceDirectoryId') is not None:
self.resource_directory_id = m.get('ResourceDirectoryId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class CreateCloudAccountResponseBody(TeaModel):
def __init__(self, account=None, request_id=None):
self.account = account # type: CreateCloudAccountResponseBodyAccount
self.request_id = request_id # type: str
def validate(self):
if self.account:
self.account.validate()
def to_map(self):
_map = super(CreateCloudAccountResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account is not None:
result['Account'] = self.account.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Account') is not None:
temp_model = CreateCloudAccountResponseBodyAccount()
self.account = temp_model.from_map(m['Account'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateCloudAccountResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateCloudAccountResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateCloudAccountResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateCloudAccountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateFolderRequest(TeaModel):
def __init__(self, name=None, parent_folder_id=None):
self.name = name # type: str
self.parent_folder_id = parent_folder_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateFolderRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.name is not None:
result['Name'] = self.name
if self.parent_folder_id is not None:
result['ParentFolderId'] = self.parent_folder_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ParentFolderId') is not None:
self.parent_folder_id = m.get('ParentFolderId')
return self
class CreateFolderResponseBodyFolder(TeaModel):
def __init__(self, create_date=None, folder_id=None, name=None, parent_folder_id=None):
self.create_date = create_date # type: str
self.folder_id = folder_id # type: str
self.name = name # type: str
self.parent_folder_id = parent_folder_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateFolderResponseBodyFolder, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.name is not None:
result['Name'] = self.name
if self.parent_folder_id is not None:
result['ParentFolderId'] = self.parent_folder_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ParentFolderId') is not None:
self.parent_folder_id = m.get('ParentFolderId')
return self
class CreateFolderResponseBody(TeaModel):
def __init__(self, folder=None, request_id=None):
self.folder = folder # type: CreateFolderResponseBodyFolder
self.request_id = request_id # type: str
def validate(self):
if self.folder:
self.folder.validate()
def to_map(self):
_map = super(CreateFolderResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.folder is not None:
result['Folder'] = self.folder.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Folder') is not None:
temp_model = CreateFolderResponseBodyFolder()
self.folder = temp_model.from_map(m['Folder'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateFolderResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateFolderResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateFolderResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateFolderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreatePolicyRequest(TeaModel):
def __init__(self, description=None, policy_document=None, policy_name=None):
self.description = description # type: str
self.policy_document = policy_document # type: str
self.policy_name = policy_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreatePolicyRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.description is not None:
result['Description'] = self.description
if self.policy_document is not None:
result['PolicyDocument'] = self.policy_document
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('PolicyDocument') is not None:
self.policy_document = m.get('PolicyDocument')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
return self
class CreatePolicyResponseBodyPolicy(TeaModel):
def __init__(self, create_date=None, default_version=None, description=None, policy_name=None, policy_type=None):
self.create_date = create_date # type: str
self.default_version = default_version # type: str
self.description = description # type: str
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreatePolicyResponseBodyPolicy, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.default_version is not None:
result['DefaultVersion'] = self.default_version
if self.description is not None:
result['Description'] = self.description
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DefaultVersion') is not None:
self.default_version = m.get('DefaultVersion')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
return self
class CreatePolicyResponseBody(TeaModel):
def __init__(self, policy=None, request_id=None):
self.policy = policy # type: CreatePolicyResponseBodyPolicy
self.request_id = request_id # type: str
def validate(self):
if self.policy:
self.policy.validate()
def to_map(self):
_map = super(CreatePolicyResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy is not None:
result['Policy'] = self.policy.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Policy') is not None:
temp_model = CreatePolicyResponseBodyPolicy()
self.policy = temp_model.from_map(m['Policy'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreatePolicyResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreatePolicyResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreatePolicyResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreatePolicyResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreatePolicyVersionRequest(TeaModel):
def __init__(self, policy_document=None, policy_name=None, set_as_default=None):
self.policy_document = policy_document # type: str
self.policy_name = policy_name # type: str
self.set_as_default = set_as_default # type: bool
def validate(self):
pass
def to_map(self):
_map = super(CreatePolicyVersionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_document is not None:
result['PolicyDocument'] = self.policy_document
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.set_as_default is not None:
result['SetAsDefault'] = self.set_as_default
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyDocument') is not None:
self.policy_document = m.get('PolicyDocument')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('SetAsDefault') is not None:
self.set_as_default = m.get('SetAsDefault')
return self
class CreatePolicyVersionResponseBodyPolicyVersion(TeaModel):
def __init__(self, create_date=None, is_default_version=None, version_id=None):
self.create_date = create_date # type: str
self.is_default_version = is_default_version # type: bool
self.version_id = version_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreatePolicyVersionResponseBodyPolicyVersion, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.is_default_version is not None:
result['IsDefaultVersion'] = self.is_default_version
if self.version_id is not None:
result['VersionId'] = self.version_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('IsDefaultVersion') is not None:
self.is_default_version = m.get('IsDefaultVersion')
if m.get('VersionId') is not None:
self.version_id = m.get('VersionId')
return self
class CreatePolicyVersionResponseBody(TeaModel):
def __init__(self, policy_version=None, request_id=None):
self.policy_version = policy_version # type: CreatePolicyVersionResponseBodyPolicyVersion
self.request_id = request_id # type: str
def validate(self):
if self.policy_version:
self.policy_version.validate()
def to_map(self):
_map = super(CreatePolicyVersionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_version is not None:
result['PolicyVersion'] = self.policy_version.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyVersion') is not None:
temp_model = CreatePolicyVersionResponseBodyPolicyVersion()
self.policy_version = temp_model.from_map(m['PolicyVersion'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreatePolicyVersionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreatePolicyVersionResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreatePolicyVersionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreatePolicyVersionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateResourceAccountRequest(TeaModel):
def __init__(self, display_name=None, enable_consolidated_billing=None, parent_folder_id=None,
payer_account_id=None):
self.display_name = display_name # type: str
self.enable_consolidated_billing = enable_consolidated_billing # type: bool
self.parent_folder_id = parent_folder_id # type: str
self.payer_account_id = payer_account_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateResourceAccountRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.enable_consolidated_billing is not None:
result['EnableConsolidatedBilling'] = self.enable_consolidated_billing
if self.parent_folder_id is not None:
result['ParentFolderId'] = self.parent_folder_id
if self.payer_account_id is not None:
result['PayerAccountId'] = self.payer_account_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('EnableConsolidatedBilling') is not None:
self.enable_consolidated_billing = m.get('EnableConsolidatedBilling')
if m.get('ParentFolderId') is not None:
self.parent_folder_id = m.get('ParentFolderId')
if m.get('PayerAccountId') is not None:
self.payer_account_id = m.get('PayerAccountId')
return self
class CreateResourceAccountResponseBodyAccount(TeaModel):
def __init__(self, account_id=None, account_name=None, display_name=None, folder_id=None, join_method=None,
join_time=None, modify_time=None, resource_directory_id=None, status=None, type=None):
self.account_id = account_id # type: str
self.account_name = account_name # type: str
self.display_name = display_name # type: str
self.folder_id = folder_id # type: str
self.join_method = join_method # type: str
self.join_time = join_time # type: str
self.modify_time = modify_time # type: str
self.resource_directory_id = resource_directory_id # type: str
self.status = status # type: str
self.type = type # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateResourceAccountResponseBodyAccount, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.account_name is not None:
result['AccountName'] = self.account_name
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.join_method is not None:
result['JoinMethod'] = self.join_method
if self.join_time is not None:
result['JoinTime'] = self.join_time
if self.modify_time is not None:
result['ModifyTime'] = self.modify_time
if self.resource_directory_id is not None:
result['ResourceDirectoryId'] = self.resource_directory_id
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('AccountName') is not None:
self.account_name = m.get('AccountName')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('JoinMethod') is not None:
self.join_method = m.get('JoinMethod')
if m.get('JoinTime') is not None:
self.join_time = m.get('JoinTime')
if m.get('ModifyTime') is not None:
self.modify_time = m.get('ModifyTime')
if m.get('ResourceDirectoryId') is not None:
self.resource_directory_id = m.get('ResourceDirectoryId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class CreateResourceAccountResponseBody(TeaModel):
def __init__(self, account=None, request_id=None):
self.account = account # type: CreateResourceAccountResponseBodyAccount
self.request_id = request_id # type: str
def validate(self):
if self.account:
self.account.validate()
def to_map(self):
_map = super(CreateResourceAccountResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account is not None:
result['Account'] = self.account.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Account') is not None:
temp_model = CreateResourceAccountResponseBodyAccount()
self.account = temp_model.from_map(m['Account'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateResourceAccountResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateResourceAccountResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateResourceAccountResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateResourceAccountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateResourceGroupRequest(TeaModel):
def __init__(self, account_id=None, display_name=None, name=None):
self.account_id = account_id # type: str
self.display_name = display_name # type: str
self.name = name # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateResourceGroupRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class CreateResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus(TeaModel):
def __init__(self, region_id=None, status=None):
self.region_id = region_id # type: str
self.status = status # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus, self).to_map()
if _map is not None:
return _map
result = dict()
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class CreateResourceGroupResponseBodyResourceGroupRegionStatuses(TeaModel):
def __init__(self, region_status=None):
self.region_status = region_status # type: list[CreateResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus]
def validate(self):
if self.region_status:
for k in self.region_status:
if k:
k.validate()
def to_map(self):
_map = super(CreateResourceGroupResponseBodyResourceGroupRegionStatuses, self).to_map()
if _map is not None:
return _map
result = dict()
result['RegionStatus'] = []
if self.region_status is not None:
for k in self.region_status:
result['RegionStatus'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.region_status = []
if m.get('RegionStatus') is not None:
for k in m.get('RegionStatus'):
temp_model = CreateResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus()
self.region_status.append(temp_model.from_map(k))
return self
class CreateResourceGroupResponseBodyResourceGroup(TeaModel):
def __init__(self, account_id=None, create_date=None, display_name=None, id=None, name=None,
region_statuses=None, status=None):
self.account_id = account_id # type: str
self.create_date = create_date # type: str
self.display_name = display_name # type: str
self.id = id # type: str
self.name = name # type: str
self.region_statuses = region_statuses # type: CreateResourceGroupResponseBodyResourceGroupRegionStatuses
self.status = status # type: str
def validate(self):
if self.region_statuses:
self.region_statuses.validate()
def to_map(self):
_map = super(CreateResourceGroupResponseBodyResourceGroup, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.id is not None:
result['Id'] = self.id
if self.name is not None:
result['Name'] = self.name
if self.region_statuses is not None:
result['RegionStatuses'] = self.region_statuses.to_map()
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('RegionStatuses') is not None:
temp_model = CreateResourceGroupResponseBodyResourceGroupRegionStatuses()
self.region_statuses = temp_model.from_map(m['RegionStatuses'])
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class CreateResourceGroupResponseBody(TeaModel):
def __init__(self, request_id=None, resource_group=None):
self.request_id = request_id # type: str
self.resource_group = resource_group # type: CreateResourceGroupResponseBodyResourceGroup
def validate(self):
if self.resource_group:
self.resource_group.validate()
def to_map(self):
_map = super(CreateResourceGroupResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_group is not None:
result['ResourceGroup'] = self.resource_group.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceGroup') is not None:
temp_model = CreateResourceGroupResponseBodyResourceGroup()
self.resource_group = temp_model.from_map(m['ResourceGroup'])
return self
class CreateResourceGroupResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateResourceGroupResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateResourceGroupResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateResourceGroupResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateRoleRequest(TeaModel):
def __init__(self, assume_role_policy_document=None, description=None, max_session_duration=None,
role_name=None):
self.assume_role_policy_document = assume_role_policy_document # type: str
self.description = description # type: str
self.max_session_duration = max_session_duration # type: long
self.role_name = role_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateRoleRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.assume_role_policy_document is not None:
result['AssumeRolePolicyDocument'] = self.assume_role_policy_document
if self.description is not None:
result['Description'] = self.description
if self.max_session_duration is not None:
result['MaxSessionDuration'] = self.max_session_duration
if self.role_name is not None:
result['RoleName'] = self.role_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AssumeRolePolicyDocument') is not None:
self.assume_role_policy_document = m.get('AssumeRolePolicyDocument')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('MaxSessionDuration') is not None:
self.max_session_duration = m.get('MaxSessionDuration')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
return self
class CreateRoleResponseBodyRole(TeaModel):
def __init__(self, arn=None, assume_role_policy_document=None, create_date=None, description=None,
max_session_duration=None, role_id=None, role_name=None, role_principal_name=None):
self.arn = arn # type: str
self.assume_role_policy_document = assume_role_policy_document # type: str
self.create_date = create_date # type: str
self.description = description # type: str
self.max_session_duration = max_session_duration # type: long
self.role_id = role_id # type: str
self.role_name = role_name # type: str
self.role_principal_name = role_principal_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateRoleResponseBodyRole, self).to_map()
if _map is not None:
return _map
result = dict()
if self.arn is not None:
result['Arn'] = self.arn
if self.assume_role_policy_document is not None:
result['AssumeRolePolicyDocument'] = self.assume_role_policy_document
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.description is not None:
result['Description'] = self.description
if self.max_session_duration is not None:
result['MaxSessionDuration'] = self.max_session_duration
if self.role_id is not None:
result['RoleId'] = self.role_id
if self.role_name is not None:
result['RoleName'] = self.role_name
if self.role_principal_name is not None:
result['RolePrincipalName'] = self.role_principal_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Arn') is not None:
self.arn = m.get('Arn')
if m.get('AssumeRolePolicyDocument') is not None:
self.assume_role_policy_document = m.get('AssumeRolePolicyDocument')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('MaxSessionDuration') is not None:
self.max_session_duration = m.get('MaxSessionDuration')
if m.get('RoleId') is not None:
self.role_id = m.get('RoleId')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
if m.get('RolePrincipalName') is not None:
self.role_principal_name = m.get('RolePrincipalName')
return self
class CreateRoleResponseBody(TeaModel):
def __init__(self, request_id=None, role=None):
self.request_id = request_id # type: str
self.role = role # type: CreateRoleResponseBodyRole
def validate(self):
if self.role:
self.role.validate()
def to_map(self):
_map = super(CreateRoleResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.role is not None:
result['Role'] = self.role.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Role') is not None:
temp_model = CreateRoleResponseBodyRole()
self.role = temp_model.from_map(m['Role'])
return self
class CreateRoleResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateRoleResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateRoleResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateRoleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateServiceLinkedRoleRequest(TeaModel):
def __init__(self, custom_suffix=None, description=None, service_name=None):
self.custom_suffix = custom_suffix # type: str
self.description = description # type: str
self.service_name = service_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateServiceLinkedRoleRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.custom_suffix is not None:
result['CustomSuffix'] = self.custom_suffix
if self.description is not None:
result['Description'] = self.description
if self.service_name is not None:
result['ServiceName'] = self.service_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CustomSuffix') is not None:
self.custom_suffix = m.get('CustomSuffix')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('ServiceName') is not None:
self.service_name = m.get('ServiceName')
return self
class CreateServiceLinkedRoleResponseBodyRole(TeaModel):
def __init__(self, arn=None, assume_role_policy_document=None, create_date=None, description=None,
is_service_linked_role=None, role_id=None, role_name=None, role_principal_name=None):
self.arn = arn # type: str
self.assume_role_policy_document = assume_role_policy_document # type: str
self.create_date = create_date # type: str
self.description = description # type: str
self.is_service_linked_role = is_service_linked_role # type: bool
self.role_id = role_id # type: str
self.role_name = role_name # type: str
self.role_principal_name = role_principal_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateServiceLinkedRoleResponseBodyRole, self).to_map()
if _map is not None:
return _map
result = dict()
if self.arn is not None:
result['Arn'] = self.arn
if self.assume_role_policy_document is not None:
result['AssumeRolePolicyDocument'] = self.assume_role_policy_document
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.description is not None:
result['Description'] = self.description
if self.is_service_linked_role is not None:
result['IsServiceLinkedRole'] = self.is_service_linked_role
if self.role_id is not None:
result['RoleId'] = self.role_id
if self.role_name is not None:
result['RoleName'] = self.role_name
if self.role_principal_name is not None:
result['RolePrincipalName'] = self.role_principal_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Arn') is not None:
self.arn = m.get('Arn')
if m.get('AssumeRolePolicyDocument') is not None:
self.assume_role_policy_document = m.get('AssumeRolePolicyDocument')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('IsServiceLinkedRole') is not None:
self.is_service_linked_role = m.get('IsServiceLinkedRole')
if m.get('RoleId') is not None:
self.role_id = m.get('RoleId')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
if m.get('RolePrincipalName') is not None:
self.role_principal_name = m.get('RolePrincipalName')
return self
class CreateServiceLinkedRoleResponseBody(TeaModel):
def __init__(self, request_id=None, role=None):
self.request_id = request_id # type: str
self.role = role # type: CreateServiceLinkedRoleResponseBodyRole
def validate(self):
if self.role:
self.role.validate()
def to_map(self):
_map = super(CreateServiceLinkedRoleResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.role is not None:
result['Role'] = self.role.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Role') is not None:
temp_model = CreateServiceLinkedRoleResponseBodyRole()
self.role = temp_model.from_map(m['Role'])
return self
class CreateServiceLinkedRoleResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateServiceLinkedRoleResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateServiceLinkedRoleResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateServiceLinkedRoleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteFolderRequest(TeaModel):
def __init__(self, folder_id=None):
self.folder_id = folder_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteFolderRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.folder_id is not None:
result['FolderId'] = self.folder_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
return self
class DeleteFolderResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteFolderResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteFolderResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteFolderResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteFolderResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteFolderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteInvalidCloudAccountRecordRequest(TeaModel):
def __init__(self, record_id=None):
self.record_id = record_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteInvalidCloudAccountRecordRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.record_id is not None:
result['RecordId'] = self.record_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
return self
class DeleteInvalidCloudAccountRecordResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteInvalidCloudAccountRecordResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteInvalidCloudAccountRecordResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteInvalidCloudAccountRecordResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteInvalidCloudAccountRecordResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteInvalidCloudAccountRecordResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeletePolicyRequest(TeaModel):
def __init__(self, policy_name=None):
self.policy_name = policy_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeletePolicyRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
return self
class DeletePolicyResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeletePolicyResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeletePolicyResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeletePolicyResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeletePolicyResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeletePolicyResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeletePolicyVersionRequest(TeaModel):
def __init__(self, policy_name=None, version_id=None):
self.policy_name = policy_name # type: str
self.version_id = version_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeletePolicyVersionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.version_id is not None:
result['VersionId'] = self.version_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('VersionId') is not None:
self.version_id = m.get('VersionId')
return self
class DeletePolicyVersionResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeletePolicyVersionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeletePolicyVersionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeletePolicyVersionResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeletePolicyVersionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeletePolicyVersionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteResourceGroupRequest(TeaModel):
def __init__(self, account_id=None, resource_group_id=None):
self.account_id = account_id # type: str
self.resource_group_id = resource_group_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteResourceGroupRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
return self
class DeleteResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus(TeaModel):
def __init__(self, region_id=None, status=None):
self.region_id = region_id # type: str
self.status = status # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus, self).to_map()
if _map is not None:
return _map
result = dict()
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class DeleteResourceGroupResponseBodyResourceGroupRegionStatuses(TeaModel):
def __init__(self, region_status=None):
self.region_status = region_status # type: list[DeleteResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus]
def validate(self):
if self.region_status:
for k in self.region_status:
if k:
k.validate()
def to_map(self):
_map = super(DeleteResourceGroupResponseBodyResourceGroupRegionStatuses, self).to_map()
if _map is not None:
return _map
result = dict()
result['RegionStatus'] = []
if self.region_status is not None:
for k in self.region_status:
result['RegionStatus'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.region_status = []
if m.get('RegionStatus') is not None:
for k in m.get('RegionStatus'):
temp_model = DeleteResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus()
self.region_status.append(temp_model.from_map(k))
return self
class DeleteResourceGroupResponseBodyResourceGroup(TeaModel):
def __init__(self, account_id=None, create_date=None, display_name=None, id=None, name=None,
region_statuses=None, status=None):
self.account_id = account_id # type: str
self.create_date = create_date # type: str
self.display_name = display_name # type: str
self.id = id # type: str
self.name = name # type: str
self.region_statuses = region_statuses # type: DeleteResourceGroupResponseBodyResourceGroupRegionStatuses
self.status = status # type: str
def validate(self):
if self.region_statuses:
self.region_statuses.validate()
def to_map(self):
_map = super(DeleteResourceGroupResponseBodyResourceGroup, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.id is not None:
result['Id'] = self.id
if self.name is not None:
result['Name'] = self.name
if self.region_statuses is not None:
result['RegionStatuses'] = self.region_statuses.to_map()
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('RegionStatuses') is not None:
temp_model = DeleteResourceGroupResponseBodyResourceGroupRegionStatuses()
self.region_statuses = temp_model.from_map(m['RegionStatuses'])
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class DeleteResourceGroupResponseBody(TeaModel):
def __init__(self, request_id=None, resource_group=None):
self.request_id = request_id # type: str
self.resource_group = resource_group # type: DeleteResourceGroupResponseBodyResourceGroup
def validate(self):
if self.resource_group:
self.resource_group.validate()
def to_map(self):
_map = super(DeleteResourceGroupResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_group is not None:
result['ResourceGroup'] = self.resource_group.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceGroup') is not None:
temp_model = DeleteResourceGroupResponseBodyResourceGroup()
self.resource_group = temp_model.from_map(m['ResourceGroup'])
return self
class DeleteResourceGroupResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteResourceGroupResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteResourceGroupResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteResourceGroupResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteRoleRequest(TeaModel):
def __init__(self, role_name=None):
self.role_name = role_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteRoleRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.role_name is not None:
result['RoleName'] = self.role_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
return self
class DeleteRoleResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteRoleResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteRoleResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteRoleResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteRoleResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteRoleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteServiceLinkedRoleRequest(TeaModel):
def __init__(self, role_name=None):
self.role_name = role_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteServiceLinkedRoleRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.role_name is not None:
result['RoleName'] = self.role_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
return self
class DeleteServiceLinkedRoleResponseBody(TeaModel):
def __init__(self, deletion_task_id=None, request_id=None):
self.deletion_task_id = deletion_task_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteServiceLinkedRoleResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.deletion_task_id is not None:
result['DeletionTaskId'] = self.deletion_task_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DeletionTaskId') is not None:
self.deletion_task_id = m.get('DeletionTaskId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteServiceLinkedRoleResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteServiceLinkedRoleResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteServiceLinkedRoleResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteServiceLinkedRoleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DestoryResourceDirectoryResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DestoryResourceDirectoryResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DestoryResourceDirectoryResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DestoryResourceDirectoryResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DestoryResourceDirectoryResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DestoryResourceDirectoryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DestroyResourceDirectoryResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DestroyResourceDirectoryResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DestroyResourceDirectoryResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DestroyResourceDirectoryResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DestroyResourceDirectoryResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DestroyResourceDirectoryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DetachPolicyRequest(TeaModel):
def __init__(self, account_id=None, policy_name=None, policy_type=None, principal_name=None,
principal_type=None, resource_group_id=None):
self.account_id = account_id # type: str
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
self.principal_name = principal_name # type: str
self.principal_type = principal_type # type: str
self.resource_group_id = resource_group_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DetachPolicyRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
if self.principal_name is not None:
result['PrincipalName'] = self.principal_name
if self.principal_type is not None:
result['PrincipalType'] = self.principal_type
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
if m.get('PrincipalName') is not None:
self.principal_name = m.get('PrincipalName')
if m.get('PrincipalType') is not None:
self.principal_type = m.get('PrincipalType')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
return self
class DetachPolicyResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DetachPolicyResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DetachPolicyResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DetachPolicyResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DetachPolicyResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DetachPolicyResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAccountSummaryRequest(TeaModel):
def __init__(self, account_id=None):
self.account_id = account_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAccountSummaryRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
return self
class GetAccountSummaryResponseBodySummaryMap(TeaModel):
def __init__(self, attached_policies_per_group_quota=None, attached_policies_per_role_quota=None,
attached_policies_per_user_quota=None, attached_system_policies_per_group_quota=None,
attached_system_policies_per_role_quota=None, attached_system_policies_per_user_quota=None, policies=None, policies_quota=None,
policy_size_quota=None, resource_groups=None, resource_groups_quota=None, roles=None, roles_quota=None,
versions_per_policy_quota=None):
self.attached_policies_per_group_quota = attached_policies_per_group_quota # type: int
self.attached_policies_per_role_quota = attached_policies_per_role_quota # type: int
self.attached_policies_per_user_quota = attached_policies_per_user_quota # type: int
self.attached_system_policies_per_group_quota = attached_system_policies_per_group_quota # type: int
self.attached_system_policies_per_role_quota = attached_system_policies_per_role_quota # type: int
self.attached_system_policies_per_user_quota = attached_system_policies_per_user_quota # type: int
self.policies = policies # type: int
self.policies_quota = policies_quota # type: int
self.policy_size_quota = policy_size_quota # type: int
self.resource_groups = resource_groups # type: int
self.resource_groups_quota = resource_groups_quota # type: int
self.roles = roles # type: int
self.roles_quota = roles_quota # type: int
self.versions_per_policy_quota = versions_per_policy_quota # type: int
def validate(self):
pass
def to_map(self):
_map = super(GetAccountSummaryResponseBodySummaryMap, self).to_map()
if _map is not None:
return _map
result = dict()
if self.attached_policies_per_group_quota is not None:
result['AttachedPoliciesPerGroupQuota'] = self.attached_policies_per_group_quota
if self.attached_policies_per_role_quota is not None:
result['AttachedPoliciesPerRoleQuota'] = self.attached_policies_per_role_quota
if self.attached_policies_per_user_quota is not None:
result['AttachedPoliciesPerUserQuota'] = self.attached_policies_per_user_quota
if self.attached_system_policies_per_group_quota is not None:
result['AttachedSystemPoliciesPerGroupQuota'] = self.attached_system_policies_per_group_quota
if self.attached_system_policies_per_role_quota is not None:
result['AttachedSystemPoliciesPerRoleQuota'] = self.attached_system_policies_per_role_quota
if self.attached_system_policies_per_user_quota is not None:
result['AttachedSystemPoliciesPerUserQuota'] = self.attached_system_policies_per_user_quota
if self.policies is not None:
result['Policies'] = self.policies
if self.policies_quota is not None:
result['PoliciesQuota'] = self.policies_quota
if self.policy_size_quota is not None:
result['PolicySizeQuota'] = self.policy_size_quota
if self.resource_groups is not None:
result['ResourceGroups'] = self.resource_groups
if self.resource_groups_quota is not None:
result['ResourceGroupsQuota'] = self.resource_groups_quota
if self.roles is not None:
result['Roles'] = self.roles
if self.roles_quota is not None:
result['RolesQuota'] = self.roles_quota
if self.versions_per_policy_quota is not None:
result['VersionsPerPolicyQuota'] = self.versions_per_policy_quota
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AttachedPoliciesPerGroupQuota') is not None:
self.attached_policies_per_group_quota = m.get('AttachedPoliciesPerGroupQuota')
if m.get('AttachedPoliciesPerRoleQuota') is not None:
self.attached_policies_per_role_quota = m.get('AttachedPoliciesPerRoleQuota')
if m.get('AttachedPoliciesPerUserQuota') is not None:
self.attached_policies_per_user_quota = m.get('AttachedPoliciesPerUserQuota')
if m.get('AttachedSystemPoliciesPerGroupQuota') is not None:
self.attached_system_policies_per_group_quota = m.get('AttachedSystemPoliciesPerGroupQuota')
if m.get('AttachedSystemPoliciesPerRoleQuota') is not None:
self.attached_system_policies_per_role_quota = m.get('AttachedSystemPoliciesPerRoleQuota')
if m.get('AttachedSystemPoliciesPerUserQuota') is not None:
self.attached_system_policies_per_user_quota = m.get('AttachedSystemPoliciesPerUserQuota')
if m.get('Policies') is not None:
self.policies = m.get('Policies')
if m.get('PoliciesQuota') is not None:
self.policies_quota = m.get('PoliciesQuota')
if m.get('PolicySizeQuota') is not None:
self.policy_size_quota = m.get('PolicySizeQuota')
if m.get('ResourceGroups') is not None:
self.resource_groups = m.get('ResourceGroups')
if m.get('ResourceGroupsQuota') is not None:
self.resource_groups_quota = m.get('ResourceGroupsQuota')
if m.get('Roles') is not None:
self.roles = m.get('Roles')
if m.get('RolesQuota') is not None:
self.roles_quota = m.get('RolesQuota')
if m.get('VersionsPerPolicyQuota') is not None:
self.versions_per_policy_quota = m.get('VersionsPerPolicyQuota')
return self
class GetAccountSummaryResponseBody(TeaModel):
def __init__(self, request_id=None, summary_map=None):
self.request_id = request_id # type: str
self.summary_map = summary_map # type: GetAccountSummaryResponseBodySummaryMap
def validate(self):
if self.summary_map:
self.summary_map.validate()
def to_map(self):
_map = super(GetAccountSummaryResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.summary_map is not None:
result['SummaryMap'] = self.summary_map.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('SummaryMap') is not None:
temp_model = GetAccountSummaryResponseBodySummaryMap()
self.summary_map = temp_model.from_map(m['SummaryMap'])
return self
class GetAccountSummaryResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetAccountSummaryResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetAccountSummaryResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetAccountSummaryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetFolderRequest(TeaModel):
def __init__(self, folder_id=None):
self.folder_id = folder_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetFolderRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.folder_id is not None:
result['FolderId'] = self.folder_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
return self
class GetFolderResponseBodyFolder(TeaModel):
def __init__(self, create_date=None, folder_id=None, name=None, parent_folder_id=None):
self.create_date = create_date # type: str
self.folder_id = folder_id # type: str
self.name = name # type: str
self.parent_folder_id = parent_folder_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetFolderResponseBodyFolder, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.name is not None:
result['Name'] = self.name
if self.parent_folder_id is not None:
result['ParentFolderId'] = self.parent_folder_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ParentFolderId') is not None:
self.parent_folder_id = m.get('ParentFolderId')
return self
class GetFolderResponseBody(TeaModel):
def __init__(self, folder=None, request_id=None):
self.folder = folder # type: GetFolderResponseBodyFolder
self.request_id = request_id # type: str
def validate(self):
if self.folder:
self.folder.validate()
def to_map(self):
_map = super(GetFolderResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.folder is not None:
result['Folder'] = self.folder.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Folder') is not None:
temp_model = GetFolderResponseBodyFolder()
self.folder = temp_model.from_map(m['Folder'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetFolderResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetFolderResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetFolderResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetFolderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetPolicyRequest(TeaModel):
def __init__(self, language=None, policy_name=None, policy_type=None):
self.language = language # type: str
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetPolicyRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.language is not None:
result['Language'] = self.language
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
return self
class GetPolicyResponseBodyPolicy(TeaModel):
def __init__(self, attachment_count=None, create_date=None, default_version=None, description=None,
policy_document=None, policy_name=None, policy_type=None, update_date=None):
self.attachment_count = attachment_count # type: int
self.create_date = create_date # type: str
self.default_version = default_version # type: str
self.description = description # type: str
self.policy_document = policy_document # type: str
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
self.update_date = update_date # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetPolicyResponseBodyPolicy, self).to_map()
if _map is not None:
return _map
result = dict()
if self.attachment_count is not None:
result['AttachmentCount'] = self.attachment_count
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.default_version is not None:
result['DefaultVersion'] = self.default_version
if self.description is not None:
result['Description'] = self.description
if self.policy_document is not None:
result['PolicyDocument'] = self.policy_document
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
if self.update_date is not None:
result['UpdateDate'] = self.update_date
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AttachmentCount') is not None:
self.attachment_count = m.get('AttachmentCount')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DefaultVersion') is not None:
self.default_version = m.get('DefaultVersion')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('PolicyDocument') is not None:
self.policy_document = m.get('PolicyDocument')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
if m.get('UpdateDate') is not None:
self.update_date = m.get('UpdateDate')
return self
class GetPolicyResponseBody(TeaModel):
def __init__(self, policy=None, request_id=None):
self.policy = policy # type: GetPolicyResponseBodyPolicy
self.request_id = request_id # type: str
def validate(self):
if self.policy:
self.policy.validate()
def to_map(self):
_map = super(GetPolicyResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy is not None:
result['Policy'] = self.policy.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Policy') is not None:
temp_model = GetPolicyResponseBodyPolicy()
self.policy = temp_model.from_map(m['Policy'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetPolicyResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetPolicyResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetPolicyResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetPolicyResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetPolicyVersionRequest(TeaModel):
def __init__(self, policy_name=None, policy_type=None, version_id=None):
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
self.version_id = version_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetPolicyVersionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
if self.version_id is not None:
result['VersionId'] = self.version_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
if m.get('VersionId') is not None:
self.version_id = m.get('VersionId')
return self
class GetPolicyVersionResponseBodyPolicyVersion(TeaModel):
def __init__(self, create_date=None, is_default_version=None, policy_document=None, version_id=None):
self.create_date = create_date # type: str
self.is_default_version = is_default_version # type: bool
self.policy_document = policy_document # type: str
self.version_id = version_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetPolicyVersionResponseBodyPolicyVersion, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.is_default_version is not None:
result['IsDefaultVersion'] = self.is_default_version
if self.policy_document is not None:
result['PolicyDocument'] = self.policy_document
if self.version_id is not None:
result['VersionId'] = self.version_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('IsDefaultVersion') is not None:
self.is_default_version = m.get('IsDefaultVersion')
if m.get('PolicyDocument') is not None:
self.policy_document = m.get('PolicyDocument')
if m.get('VersionId') is not None:
self.version_id = m.get('VersionId')
return self
class GetPolicyVersionResponseBody(TeaModel):
def __init__(self, policy_version=None, request_id=None):
self.policy_version = policy_version # type: GetPolicyVersionResponseBodyPolicyVersion
self.request_id = request_id # type: str
def validate(self):
if self.policy_version:
self.policy_version.validate()
def to_map(self):
_map = super(GetPolicyVersionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_version is not None:
result['PolicyVersion'] = self.policy_version.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyVersion') is not None:
temp_model = GetPolicyVersionResponseBodyPolicyVersion()
self.policy_version = temp_model.from_map(m['PolicyVersion'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetPolicyVersionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetPolicyVersionResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetPolicyVersionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetPolicyVersionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetResourceDirectoryResponseBodyResourceDirectory(TeaModel):
def __init__(self, create_date=None, master_account_id=None, master_account_name=None,
resource_directory_id=None, root_folder_id=None):
self.create_date = create_date # type: str
self.master_account_id = master_account_id # type: str
self.master_account_name = master_account_name # type: str
self.resource_directory_id = resource_directory_id # type: str
self.root_folder_id = root_folder_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetResourceDirectoryResponseBodyResourceDirectory, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.master_account_id is not None:
result['MasterAccountId'] = self.master_account_id
if self.master_account_name is not None:
result['MasterAccountName'] = self.master_account_name
if self.resource_directory_id is not None:
result['ResourceDirectoryId'] = self.resource_directory_id
if self.root_folder_id is not None:
result['RootFolderId'] = self.root_folder_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('MasterAccountId') is not None:
self.master_account_id = m.get('MasterAccountId')
if m.get('MasterAccountName') is not None:
self.master_account_name = m.get('MasterAccountName')
if m.get('ResourceDirectoryId') is not None:
self.resource_directory_id = m.get('ResourceDirectoryId')
if m.get('RootFolderId') is not None:
self.root_folder_id = m.get('RootFolderId')
return self
class GetResourceDirectoryResponseBody(TeaModel):
def __init__(self, request_id=None, resource_directory=None):
self.request_id = request_id # type: str
self.resource_directory = resource_directory # type: GetResourceDirectoryResponseBodyResourceDirectory
def validate(self):
if self.resource_directory:
self.resource_directory.validate()
def to_map(self):
_map = super(GetResourceDirectoryResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_directory is not None:
result['ResourceDirectory'] = self.resource_directory.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceDirectory') is not None:
temp_model = GetResourceDirectoryResponseBodyResourceDirectory()
self.resource_directory = temp_model.from_map(m['ResourceDirectory'])
return self
class GetResourceDirectoryResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetResourceDirectoryResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetResourceDirectoryResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetResourceDirectoryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetResourceDirectoryAccountRequest(TeaModel):
def __init__(self, account_id=None):
self.account_id = account_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetResourceDirectoryAccountRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
return self
class GetResourceDirectoryAccountResponseBodyAccount(TeaModel):
def __init__(self, account_id=None, account_name=None, display_name=None, folder_id=None,
identity_information=None, join_method=None, join_time=None, modify_time=None, resource_directory_id=None, status=None,
type=None):
self.account_id = account_id # type: str
self.account_name = account_name # type: str
self.display_name = display_name # type: str
self.folder_id = folder_id # type: str
self.identity_information = identity_information # type: str
self.join_method = join_method # type: str
self.join_time = join_time # type: str
self.modify_time = modify_time # type: str
self.resource_directory_id = resource_directory_id # type: str
self.status = status # type: str
self.type = type # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetResourceDirectoryAccountResponseBodyAccount, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.account_name is not None:
result['AccountName'] = self.account_name
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.identity_information is not None:
result['IdentityInformation'] = self.identity_information
if self.join_method is not None:
result['JoinMethod'] = self.join_method
if self.join_time is not None:
result['JoinTime'] = self.join_time
if self.modify_time is not None:
result['ModifyTime'] = self.modify_time
if self.resource_directory_id is not None:
result['ResourceDirectoryId'] = self.resource_directory_id
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('AccountName') is not None:
self.account_name = m.get('AccountName')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('IdentityInformation') is not None:
self.identity_information = m.get('IdentityInformation')
if m.get('JoinMethod') is not None:
self.join_method = m.get('JoinMethod')
if m.get('JoinTime') is not None:
self.join_time = m.get('JoinTime')
if m.get('ModifyTime') is not None:
self.modify_time = m.get('ModifyTime')
if m.get('ResourceDirectoryId') is not None:
self.resource_directory_id = m.get('ResourceDirectoryId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class GetResourceDirectoryAccountResponseBody(TeaModel):
def __init__(self, account=None, request_id=None):
self.account = account # type: GetResourceDirectoryAccountResponseBodyAccount
self.request_id = request_id # type: str
def validate(self):
if self.account:
self.account.validate()
def to_map(self):
_map = super(GetResourceDirectoryAccountResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account is not None:
result['Account'] = self.account.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Account') is not None:
temp_model = GetResourceDirectoryAccountResponseBodyAccount()
self.account = temp_model.from_map(m['Account'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetResourceDirectoryAccountResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetResourceDirectoryAccountResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetResourceDirectoryAccountResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetResourceDirectoryAccountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetResourceGroupRequest(TeaModel):
def __init__(self, account_id=None, resource_group_id=None):
self.account_id = account_id # type: str
self.resource_group_id = resource_group_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetResourceGroupRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
return self
class GetResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus(TeaModel):
def __init__(self, region_id=None, status=None):
self.region_id = region_id # type: str
self.status = status # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus, self).to_map()
if _map is not None:
return _map
result = dict()
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class GetResourceGroupResponseBodyResourceGroupRegionStatuses(TeaModel):
def __init__(self, region_status=None):
self.region_status = region_status # type: list[GetResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus]
def validate(self):
if self.region_status:
for k in self.region_status:
if k:
k.validate()
def to_map(self):
_map = super(GetResourceGroupResponseBodyResourceGroupRegionStatuses, self).to_map()
if _map is not None:
return _map
result = dict()
result['RegionStatus'] = []
if self.region_status is not None:
for k in self.region_status:
result['RegionStatus'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.region_status = []
if m.get('RegionStatus') is not None:
for k in m.get('RegionStatus'):
temp_model = GetResourceGroupResponseBodyResourceGroupRegionStatusesRegionStatus()
self.region_status.append(temp_model.from_map(k))
return self
class GetResourceGroupResponseBodyResourceGroup(TeaModel):
def __init__(self, account_id=None, create_date=None, display_name=None, id=None, name=None,
region_statuses=None, status=None):
self.account_id = account_id # type: str
self.create_date = create_date # type: str
self.display_name = display_name # type: str
self.id = id # type: str
self.name = name # type: str
self.region_statuses = region_statuses # type: GetResourceGroupResponseBodyResourceGroupRegionStatuses
self.status = status # type: str
def validate(self):
if self.region_statuses:
self.region_statuses.validate()
def to_map(self):
_map = super(GetResourceGroupResponseBodyResourceGroup, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.id is not None:
result['Id'] = self.id
if self.name is not None:
result['Name'] = self.name
if self.region_statuses is not None:
result['RegionStatuses'] = self.region_statuses.to_map()
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('RegionStatuses') is not None:
temp_model = GetResourceGroupResponseBodyResourceGroupRegionStatuses()
self.region_statuses = temp_model.from_map(m['RegionStatuses'])
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class GetResourceGroupResponseBody(TeaModel):
def __init__(self, request_id=None, resource_group=None):
self.request_id = request_id # type: str
self.resource_group = resource_group # type: GetResourceGroupResponseBodyResourceGroup
def validate(self):
if self.resource_group:
self.resource_group.validate()
def to_map(self):
_map = super(GetResourceGroupResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_group is not None:
result['ResourceGroup'] = self.resource_group.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceGroup') is not None:
temp_model = GetResourceGroupResponseBodyResourceGroup()
self.resource_group = temp_model.from_map(m['ResourceGroup'])
return self
class GetResourceGroupResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetResourceGroupResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetResourceGroupResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetResourceGroupResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetRoleRequest(TeaModel):
def __init__(self, language=None, role_name=None):
self.language = language # type: str
self.role_name = role_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetRoleRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.language is not None:
result['Language'] = self.language
if self.role_name is not None:
result['RoleName'] = self.role_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
return self
class GetRoleResponseBodyRoleLatestDeletionTask(TeaModel):
def __init__(self, create_date=None, deletion_task_id=None):
self.create_date = create_date # type: str
self.deletion_task_id = deletion_task_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetRoleResponseBodyRoleLatestDeletionTask, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.deletion_task_id is not None:
result['DeletionTaskId'] = self.deletion_task_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DeletionTaskId') is not None:
self.deletion_task_id = m.get('DeletionTaskId')
return self
class GetRoleResponseBodyRole(TeaModel):
def __init__(self, arn=None, assume_role_policy_document=None, create_date=None, description=None,
is_service_linked_role=None, latest_deletion_task=None, max_session_duration=None, role_id=None, role_name=None,
role_principal_name=None, update_date=None):
self.arn = arn # type: str
self.assume_role_policy_document = assume_role_policy_document # type: str
self.create_date = create_date # type: str
self.description = description # type: str
self.is_service_linked_role = is_service_linked_role # type: bool
self.latest_deletion_task = latest_deletion_task # type: GetRoleResponseBodyRoleLatestDeletionTask
self.max_session_duration = max_session_duration # type: long
self.role_id = role_id # type: str
self.role_name = role_name # type: str
self.role_principal_name = role_principal_name # type: str
self.update_date = update_date # type: str
def validate(self):
if self.latest_deletion_task:
self.latest_deletion_task.validate()
def to_map(self):
_map = super(GetRoleResponseBodyRole, self).to_map()
if _map is not None:
return _map
result = dict()
if self.arn is not None:
result['Arn'] = self.arn
if self.assume_role_policy_document is not None:
result['AssumeRolePolicyDocument'] = self.assume_role_policy_document
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.description is not None:
result['Description'] = self.description
if self.is_service_linked_role is not None:
result['IsServiceLinkedRole'] = self.is_service_linked_role
if self.latest_deletion_task is not None:
result['LatestDeletionTask'] = self.latest_deletion_task.to_map()
if self.max_session_duration is not None:
result['MaxSessionDuration'] = self.max_session_duration
if self.role_id is not None:
result['RoleId'] = self.role_id
if self.role_name is not None:
result['RoleName'] = self.role_name
if self.role_principal_name is not None:
result['RolePrincipalName'] = self.role_principal_name
if self.update_date is not None:
result['UpdateDate'] = self.update_date
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Arn') is not None:
self.arn = m.get('Arn')
if m.get('AssumeRolePolicyDocument') is not None:
self.assume_role_policy_document = m.get('AssumeRolePolicyDocument')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('IsServiceLinkedRole') is not None:
self.is_service_linked_role = m.get('IsServiceLinkedRole')
if m.get('LatestDeletionTask') is not None:
temp_model = GetRoleResponseBodyRoleLatestDeletionTask()
self.latest_deletion_task = temp_model.from_map(m['LatestDeletionTask'])
if m.get('MaxSessionDuration') is not None:
self.max_session_duration = m.get('MaxSessionDuration')
if m.get('RoleId') is not None:
self.role_id = m.get('RoleId')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
if m.get('RolePrincipalName') is not None:
self.role_principal_name = m.get('RolePrincipalName')
if m.get('UpdateDate') is not None:
self.update_date = m.get('UpdateDate')
return self
class GetRoleResponseBody(TeaModel):
def __init__(self, request_id=None, role=None):
self.request_id = request_id # type: str
self.role = role # type: GetRoleResponseBodyRole
def validate(self):
if self.role:
self.role.validate()
def to_map(self):
_map = super(GetRoleResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.role is not None:
result['Role'] = self.role.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Role') is not None:
temp_model = GetRoleResponseBodyRole()
self.role = temp_model.from_map(m['Role'])
return self
class GetRoleResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetRoleResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetRoleResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetRoleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetServiceLinkedRoleDeletionStatusRequest(TeaModel):
def __init__(self, deletion_task_id=None):
self.deletion_task_id = deletion_task_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetServiceLinkedRoleDeletionStatusRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.deletion_task_id is not None:
result['DeletionTaskId'] = self.deletion_task_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DeletionTaskId') is not None:
self.deletion_task_id = m.get('DeletionTaskId')
return self
class GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsagesRoleUsageResources(TeaModel):
def __init__(self, resource=None):
self.resource = resource # type: list[str]
def validate(self):
pass
def to_map(self):
_map = super(GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsagesRoleUsageResources, self).to_map()
if _map is not None:
return _map
result = dict()
if self.resource is not None:
result['Resource'] = self.resource
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Resource') is not None:
self.resource = m.get('Resource')
return self
class GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsagesRoleUsage(TeaModel):
def __init__(self, region=None, resources=None):
self.region = region # type: str
self.resources = resources # type: GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsagesRoleUsageResources
def validate(self):
if self.resources:
self.resources.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsagesRoleUsage, self).to_map()
if _map is not None:
return _map
result = dict()
if self.region is not None:
result['Region'] = self.region
if self.resources is not None:
result['Resources'] = self.resources.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('Resources') is not None:
temp_model = GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsagesRoleUsageResources()
self.resources = temp_model.from_map(m['Resources'])
return self
class GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsages(TeaModel):
def __init__(self, role_usage=None):
self.role_usage = role_usage # type: list[GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsagesRoleUsage]
def validate(self):
if self.role_usage:
for k in self.role_usage:
if k:
k.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsages, self).to_map()
if _map is not None:
return _map
result = dict()
result['RoleUsage'] = []
if self.role_usage is not None:
for k in self.role_usage:
result['RoleUsage'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.role_usage = []
if m.get('RoleUsage') is not None:
for k in m.get('RoleUsage'):
temp_model = GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsagesRoleUsage()
self.role_usage.append(temp_model.from_map(k))
return self
class GetServiceLinkedRoleDeletionStatusResponseBodyReason(TeaModel):
def __init__(self, message=None, role_usages=None):
self.message = message # type: str
self.role_usages = role_usages # type: GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsages
def validate(self):
if self.role_usages:
self.role_usages.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleDeletionStatusResponseBodyReason, self).to_map()
if _map is not None:
return _map
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.role_usages is not None:
result['RoleUsages'] = self.role_usages.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RoleUsages') is not None:
temp_model = GetServiceLinkedRoleDeletionStatusResponseBodyReasonRoleUsages()
self.role_usages = temp_model.from_map(m['RoleUsages'])
return self
class GetServiceLinkedRoleDeletionStatusResponseBody(TeaModel):
def __init__(self, reason=None, request_id=None, status=None):
self.reason = reason # type: GetServiceLinkedRoleDeletionStatusResponseBodyReason
self.request_id = request_id # type: str
self.status = status # type: str
def validate(self):
if self.reason:
self.reason.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleDeletionStatusResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.reason is not None:
result['Reason'] = self.reason.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Reason') is not None:
temp_model = GetServiceLinkedRoleDeletionStatusResponseBodyReason()
self.reason = temp_model.from_map(m['Reason'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class GetServiceLinkedRoleDeletionStatusResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetServiceLinkedRoleDeletionStatusResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleDeletionStatusResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetServiceLinkedRoleDeletionStatusResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetServiceLinkedRoleTemplateRequest(TeaModel):
def __init__(self, service_name=None):
self.service_name = service_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetServiceLinkedRoleTemplateRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.service_name is not None:
result['ServiceName'] = self.service_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ServiceName') is not None:
self.service_name = m.get('ServiceName')
return self
class GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplateRoleDescriptionsRoleDescription(TeaModel):
def __init__(self, description=None, language=None):
self.description = description # type: str
self.language = language # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplateRoleDescriptionsRoleDescription, self).to_map()
if _map is not None:
return _map
result = dict()
if self.description is not None:
result['Description'] = self.description
if self.language is not None:
result['Language'] = self.language
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('Language') is not None:
self.language = m.get('Language')
return self
class GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplateRoleDescriptions(TeaModel):
def __init__(self, role_description=None):
self.role_description = role_description # type: list[GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplateRoleDescriptionsRoleDescription]
def validate(self):
if self.role_description:
for k in self.role_description:
if k:
k.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplateRoleDescriptions, self).to_map()
if _map is not None:
return _map
result = dict()
result['RoleDescription'] = []
if self.role_description is not None:
for k in self.role_description:
result['RoleDescription'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.role_description = []
if m.get('RoleDescription') is not None:
for k in m.get('RoleDescription'):
temp_model = GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplateRoleDescriptionsRoleDescription()
self.role_description.append(temp_model.from_map(k))
return self
class GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplate(TeaModel):
def __init__(self, multiple_roles_allowed=None, role_descriptions=None, role_name_prefix=None,
service_name=None, system_policy_name=None):
self.multiple_roles_allowed = multiple_roles_allowed # type: bool
self.role_descriptions = role_descriptions # type: GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplateRoleDescriptions
self.role_name_prefix = role_name_prefix # type: str
self.service_name = service_name # type: str
self.system_policy_name = system_policy_name # type: str
def validate(self):
if self.role_descriptions:
self.role_descriptions.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplate, self).to_map()
if _map is not None:
return _map
result = dict()
if self.multiple_roles_allowed is not None:
result['MultipleRolesAllowed'] = self.multiple_roles_allowed
if self.role_descriptions is not None:
result['RoleDescriptions'] = self.role_descriptions.to_map()
if self.role_name_prefix is not None:
result['RoleNamePrefix'] = self.role_name_prefix
if self.service_name is not None:
result['ServiceName'] = self.service_name
if self.system_policy_name is not None:
result['SystemPolicyName'] = self.system_policy_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('MultipleRolesAllowed') is not None:
self.multiple_roles_allowed = m.get('MultipleRolesAllowed')
if m.get('RoleDescriptions') is not None:
temp_model = GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplateRoleDescriptions()
self.role_descriptions = temp_model.from_map(m['RoleDescriptions'])
if m.get('RoleNamePrefix') is not None:
self.role_name_prefix = m.get('RoleNamePrefix')
if m.get('ServiceName') is not None:
self.service_name = m.get('ServiceName')
if m.get('SystemPolicyName') is not None:
self.system_policy_name = m.get('SystemPolicyName')
return self
class GetServiceLinkedRoleTemplateResponseBody(TeaModel):
def __init__(self, request_id=None, service_linked_role_template=None):
self.request_id = request_id # type: str
self.service_linked_role_template = service_linked_role_template # type: GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplate
def validate(self):
if self.service_linked_role_template:
self.service_linked_role_template.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleTemplateResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.service_linked_role_template is not None:
result['ServiceLinkedRoleTemplate'] = self.service_linked_role_template.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ServiceLinkedRoleTemplate') is not None:
temp_model = GetServiceLinkedRoleTemplateResponseBodyServiceLinkedRoleTemplate()
self.service_linked_role_template = temp_model.from_map(m['ServiceLinkedRoleTemplate'])
return self
class GetServiceLinkedRoleTemplateResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetServiceLinkedRoleTemplateResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetServiceLinkedRoleTemplateResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetServiceLinkedRoleTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class InitResourceDirectoryResponseBodyResourceDirectory(TeaModel):
def __init__(self, create_date=None, master_account_id=None, master_account_name=None,
resource_directory_id=None, root_folder_id=None):
self.create_date = create_date # type: str
self.master_account_id = master_account_id # type: str
self.master_account_name = master_account_name # type: str
self.resource_directory_id = resource_directory_id # type: str
self.root_folder_id = root_folder_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(InitResourceDirectoryResponseBodyResourceDirectory, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.master_account_id is not None:
result['MasterAccountId'] = self.master_account_id
if self.master_account_name is not None:
result['MasterAccountName'] = self.master_account_name
if self.resource_directory_id is not None:
result['ResourceDirectoryId'] = self.resource_directory_id
if self.root_folder_id is not None:
result['RootFolderId'] = self.root_folder_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('MasterAccountId') is not None:
self.master_account_id = m.get('MasterAccountId')
if m.get('MasterAccountName') is not None:
self.master_account_name = m.get('MasterAccountName')
if m.get('ResourceDirectoryId') is not None:
self.resource_directory_id = m.get('ResourceDirectoryId')
if m.get('RootFolderId') is not None:
self.root_folder_id = m.get('RootFolderId')
return self
class InitResourceDirectoryResponseBody(TeaModel):
def __init__(self, request_id=None, resource_directory=None):
self.request_id = request_id # type: str
self.resource_directory = resource_directory # type: InitResourceDirectoryResponseBodyResourceDirectory
def validate(self):
if self.resource_directory:
self.resource_directory.validate()
def to_map(self):
_map = super(InitResourceDirectoryResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_directory is not None:
result['ResourceDirectory'] = self.resource_directory.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceDirectory') is not None:
temp_model = InitResourceDirectoryResponseBodyResourceDirectory()
self.resource_directory = temp_model.from_map(m['ResourceDirectory'])
return self
class InitResourceDirectoryResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: InitResourceDirectoryResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(InitResourceDirectoryResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = InitResourceDirectoryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListAccountRecordsForParentRequest(TeaModel):
def __init__(self, page_number=None, page_size=None, parent_folder_id=None, query_keyword=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.parent_folder_id = parent_folder_id # type: str
self.query_keyword = query_keyword # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAccountRecordsForParentRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.parent_folder_id is not None:
result['ParentFolderId'] = self.parent_folder_id
if self.query_keyword is not None:
result['QueryKeyword'] = self.query_keyword
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('ParentFolderId') is not None:
self.parent_folder_id = m.get('ParentFolderId')
if m.get('QueryKeyword') is not None:
self.query_keyword = m.get('QueryKeyword')
return self
class ListAccountRecordsForParentResponseBodyRecordsRecord(TeaModel):
def __init__(self, account_id=None, account_name=None, display_name=None, folder_id=None, join_method=None,
join_time=None, modify_time=None, record_id=None, resource_directory_id=None, status=None, type=None):
self.account_id = account_id # type: str
self.account_name = account_name # type: str
self.display_name = display_name # type: str
self.folder_id = folder_id # type: str
self.join_method = join_method # type: str
self.join_time = join_time # type: str
self.modify_time = modify_time # type: str
self.record_id = record_id # type: str
self.resource_directory_id = resource_directory_id # type: str
self.status = status # type: str
self.type = type # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAccountRecordsForParentResponseBodyRecordsRecord, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.account_name is not None:
result['AccountName'] = self.account_name
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.join_method is not None:
result['JoinMethod'] = self.join_method
if self.join_time is not None:
result['JoinTime'] = self.join_time
if self.modify_time is not None:
result['ModifyTime'] = self.modify_time
if self.record_id is not None:
result['RecordId'] = self.record_id
if self.resource_directory_id is not None:
result['ResourceDirectoryId'] = self.resource_directory_id
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('AccountName') is not None:
self.account_name = m.get('AccountName')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('JoinMethod') is not None:
self.join_method = m.get('JoinMethod')
if m.get('JoinTime') is not None:
self.join_time = m.get('JoinTime')
if m.get('ModifyTime') is not None:
self.modify_time = m.get('ModifyTime')
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
if m.get('ResourceDirectoryId') is not None:
self.resource_directory_id = m.get('ResourceDirectoryId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListAccountRecordsForParentResponseBodyRecords(TeaModel):
def __init__(self, record=None):
self.record = record # type: list[ListAccountRecordsForParentResponseBodyRecordsRecord]
def validate(self):
if self.record:
for k in self.record:
if k:
k.validate()
def to_map(self):
_map = super(ListAccountRecordsForParentResponseBodyRecords, self).to_map()
if _map is not None:
return _map
result = dict()
result['Record'] = []
if self.record is not None:
for k in self.record:
result['Record'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.record = []
if m.get('Record') is not None:
for k in m.get('Record'):
temp_model = ListAccountRecordsForParentResponseBodyRecordsRecord()
self.record.append(temp_model.from_map(k))
return self
class ListAccountRecordsForParentResponseBody(TeaModel):
def __init__(self, page_number=None, page_size=None, records=None, request_id=None, total_count=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.records = records # type: ListAccountRecordsForParentResponseBodyRecords
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.records:
self.records.validate()
def to_map(self):
_map = super(ListAccountRecordsForParentResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.records is not None:
result['Records'] = self.records.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Records') is not None:
temp_model = ListAccountRecordsForParentResponseBodyRecords()
self.records = temp_model.from_map(m['Records'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListAccountRecordsForParentResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListAccountRecordsForParentResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListAccountRecordsForParentResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListAccountRecordsForParentResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListAccountsRequest(TeaModel):
def __init__(self, page_number=None, page_size=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
def validate(self):
pass
def to_map(self):
_map = super(ListAccountsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListAccountsResponseBodyAccountsAccount(TeaModel):
def __init__(self, account_id=None, display_name=None, folder_id=None, join_method=None, join_time=None,
modify_time=None, resource_directory_id=None, status=None, type=None):
self.account_id = account_id # type: str
self.display_name = display_name # type: str
self.folder_id = folder_id # type: str
self.join_method = join_method # type: str
self.join_time = join_time # type: str
self.modify_time = modify_time # type: str
self.resource_directory_id = resource_directory_id # type: str
self.status = status # type: str
self.type = type # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAccountsResponseBodyAccountsAccount, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.join_method is not None:
result['JoinMethod'] = self.join_method
if self.join_time is not None:
result['JoinTime'] = self.join_time
if self.modify_time is not None:
result['ModifyTime'] = self.modify_time
if self.resource_directory_id is not None:
result['ResourceDirectoryId'] = self.resource_directory_id
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('JoinMethod') is not None:
self.join_method = m.get('JoinMethod')
if m.get('JoinTime') is not None:
self.join_time = m.get('JoinTime')
if m.get('ModifyTime') is not None:
self.modify_time = m.get('ModifyTime')
if m.get('ResourceDirectoryId') is not None:
self.resource_directory_id = m.get('ResourceDirectoryId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListAccountsResponseBodyAccounts(TeaModel):
def __init__(self, account=None):
self.account = account # type: list[ListAccountsResponseBodyAccountsAccount]
def validate(self):
if self.account:
for k in self.account:
if k:
k.validate()
def to_map(self):
_map = super(ListAccountsResponseBodyAccounts, self).to_map()
if _map is not None:
return _map
result = dict()
result['Account'] = []
if self.account is not None:
for k in self.account:
result['Account'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.account = []
if m.get('Account') is not None:
for k in m.get('Account'):
temp_model = ListAccountsResponseBodyAccountsAccount()
self.account.append(temp_model.from_map(k))
return self
class ListAccountsResponseBody(TeaModel):
def __init__(self, accounts=None, page_number=None, page_size=None, request_id=None, total_count=None):
self.accounts = accounts # type: ListAccountsResponseBodyAccounts
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.accounts:
self.accounts.validate()
def to_map(self):
_map = super(ListAccountsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.accounts is not None:
result['Accounts'] = self.accounts.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Accounts') is not None:
temp_model = ListAccountsResponseBodyAccounts()
self.accounts = temp_model.from_map(m['Accounts'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListAccountsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListAccountsResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListAccountsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListAccountsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListAccountsForParentRequest(TeaModel):
def __init__(self, page_number=None, page_size=None, parent_folder_id=None, query_keyword=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.parent_folder_id = parent_folder_id # type: str
self.query_keyword = query_keyword # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAccountsForParentRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.parent_folder_id is not None:
result['ParentFolderId'] = self.parent_folder_id
if self.query_keyword is not None:
result['QueryKeyword'] = self.query_keyword
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('ParentFolderId') is not None:
self.parent_folder_id = m.get('ParentFolderId')
if m.get('QueryKeyword') is not None:
self.query_keyword = m.get('QueryKeyword')
return self
class ListAccountsForParentResponseBodyAccountsAccount(TeaModel):
def __init__(self, account_id=None, display_name=None, folder_id=None, join_method=None, join_time=None,
modify_time=None, resource_directory_id=None, status=None, type=None):
self.account_id = account_id # type: str
self.display_name = display_name # type: str
self.folder_id = folder_id # type: str
self.join_method = join_method # type: str
self.join_time = join_time # type: str
self.modify_time = modify_time # type: str
self.resource_directory_id = resource_directory_id # type: str
self.status = status # type: str
self.type = type # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAccountsForParentResponseBodyAccountsAccount, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.join_method is not None:
result['JoinMethod'] = self.join_method
if self.join_time is not None:
result['JoinTime'] = self.join_time
if self.modify_time is not None:
result['ModifyTime'] = self.modify_time
if self.resource_directory_id is not None:
result['ResourceDirectoryId'] = self.resource_directory_id
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('JoinMethod') is not None:
self.join_method = m.get('JoinMethod')
if m.get('JoinTime') is not None:
self.join_time = m.get('JoinTime')
if m.get('ModifyTime') is not None:
self.modify_time = m.get('ModifyTime')
if m.get('ResourceDirectoryId') is not None:
self.resource_directory_id = m.get('ResourceDirectoryId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListAccountsForParentResponseBodyAccounts(TeaModel):
def __init__(self, account=None):
self.account = account # type: list[ListAccountsForParentResponseBodyAccountsAccount]
def validate(self):
if self.account:
for k in self.account:
if k:
k.validate()
def to_map(self):
_map = super(ListAccountsForParentResponseBodyAccounts, self).to_map()
if _map is not None:
return _map
result = dict()
result['Account'] = []
if self.account is not None:
for k in self.account:
result['Account'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.account = []
if m.get('Account') is not None:
for k in m.get('Account'):
temp_model = ListAccountsForParentResponseBodyAccountsAccount()
self.account.append(temp_model.from_map(k))
return self
class ListAccountsForParentResponseBody(TeaModel):
def __init__(self, accounts=None, page_number=None, page_size=None, request_id=None, total_count=None):
self.accounts = accounts # type: ListAccountsForParentResponseBodyAccounts
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.accounts:
self.accounts.validate()
def to_map(self):
_map = super(ListAccountsForParentResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.accounts is not None:
result['Accounts'] = self.accounts.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Accounts') is not None:
temp_model = ListAccountsForParentResponseBodyAccounts()
self.accounts = temp_model.from_map(m['Accounts'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListAccountsForParentResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListAccountsForParentResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListAccountsForParentResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListAccountsForParentResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListAncestorsRequest(TeaModel):
def __init__(self, child_id=None):
self.child_id = child_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAncestorsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.child_id is not None:
result['ChildId'] = self.child_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChildId') is not None:
self.child_id = m.get('ChildId')
return self
class ListAncestorsResponseBodyFoldersFolder(TeaModel):
def __init__(self, create_date=None, folder_id=None, name=None):
self.create_date = create_date # type: str
self.folder_id = folder_id # type: str
self.name = name # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAncestorsResponseBodyFoldersFolder, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class ListAncestorsResponseBodyFolders(TeaModel):
def __init__(self, folder=None):
self.folder = folder # type: list[ListAncestorsResponseBodyFoldersFolder]
def validate(self):
if self.folder:
for k in self.folder:
if k:
k.validate()
def to_map(self):
_map = super(ListAncestorsResponseBodyFolders, self).to_map()
if _map is not None:
return _map
result = dict()
result['Folder'] = []
if self.folder is not None:
for k in self.folder:
result['Folder'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.folder = []
if m.get('Folder') is not None:
for k in m.get('Folder'):
temp_model = ListAncestorsResponseBodyFoldersFolder()
self.folder.append(temp_model.from_map(k))
return self
class ListAncestorsResponseBody(TeaModel):
def __init__(self, folders=None, request_id=None):
self.folders = folders # type: ListAncestorsResponseBodyFolders
self.request_id = request_id # type: str
def validate(self):
if self.folders:
self.folders.validate()
def to_map(self):
_map = super(ListAncestorsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.folders is not None:
result['Folders'] = self.folders.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Folders') is not None:
temp_model = ListAncestorsResponseBodyFolders()
self.folders = temp_model.from_map(m['Folders'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListAncestorsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListAncestorsResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListAncestorsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListAncestorsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListFoldersForParentRequest(TeaModel):
def __init__(self, page_number=None, page_size=None, parent_folder_id=None, query_keyword=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.parent_folder_id = parent_folder_id # type: str
self.query_keyword = query_keyword # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListFoldersForParentRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.parent_folder_id is not None:
result['ParentFolderId'] = self.parent_folder_id
if self.query_keyword is not None:
result['QueryKeyword'] = self.query_keyword
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('ParentFolderId') is not None:
self.parent_folder_id = m.get('ParentFolderId')
if m.get('QueryKeyword') is not None:
self.query_keyword = m.get('QueryKeyword')
return self
class ListFoldersForParentResponseBodyFoldersFolder(TeaModel):
def __init__(self, create_date=None, folder_id=None, name=None):
self.create_date = create_date # type: str
self.folder_id = folder_id # type: str
self.name = name # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListFoldersForParentResponseBodyFoldersFolder, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class ListFoldersForParentResponseBodyFolders(TeaModel):
def __init__(self, folder=None):
self.folder = folder # type: list[ListFoldersForParentResponseBodyFoldersFolder]
def validate(self):
if self.folder:
for k in self.folder:
if k:
k.validate()
def to_map(self):
_map = super(ListFoldersForParentResponseBodyFolders, self).to_map()
if _map is not None:
return _map
result = dict()
result['Folder'] = []
if self.folder is not None:
for k in self.folder:
result['Folder'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.folder = []
if m.get('Folder') is not None:
for k in m.get('Folder'):
temp_model = ListFoldersForParentResponseBodyFoldersFolder()
self.folder.append(temp_model.from_map(k))
return self
class ListFoldersForParentResponseBody(TeaModel):
def __init__(self, folders=None, page_number=None, page_size=None, request_id=None, total_count=None):
self.folders = folders # type: ListFoldersForParentResponseBodyFolders
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.folders:
self.folders.validate()
def to_map(self):
_map = super(ListFoldersForParentResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.folders is not None:
result['Folders'] = self.folders.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Folders') is not None:
temp_model = ListFoldersForParentResponseBodyFolders()
self.folders = temp_model.from_map(m['Folders'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListFoldersForParentResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListFoldersForParentResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListFoldersForParentResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListFoldersForParentResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListParentsRequest(TeaModel):
def __init__(self, child_id=None):
self.child_id = child_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListParentsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.child_id is not None:
result['ChildId'] = self.child_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChildId') is not None:
self.child_id = m.get('ChildId')
return self
class ListParentsResponseBodyFoldersFolder(TeaModel):
def __init__(self, create_date=None, folder_id=None, name=None):
self.create_date = create_date # type: str
self.folder_id = folder_id # type: str
self.name = name # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListParentsResponseBodyFoldersFolder, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class ListParentsResponseBodyFolders(TeaModel):
def __init__(self, folder=None):
self.folder = folder # type: list[ListParentsResponseBodyFoldersFolder]
def validate(self):
if self.folder:
for k in self.folder:
if k:
k.validate()
def to_map(self):
_map = super(ListParentsResponseBodyFolders, self).to_map()
if _map is not None:
return _map
result = dict()
result['Folder'] = []
if self.folder is not None:
for k in self.folder:
result['Folder'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.folder = []
if m.get('Folder') is not None:
for k in m.get('Folder'):
temp_model = ListParentsResponseBodyFoldersFolder()
self.folder.append(temp_model.from_map(k))
return self
class ListParentsResponseBody(TeaModel):
def __init__(self, folders=None, request_id=None):
self.folders = folders # type: ListParentsResponseBodyFolders
self.request_id = request_id # type: str
def validate(self):
if self.folders:
self.folders.validate()
def to_map(self):
_map = super(ListParentsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.folders is not None:
result['Folders'] = self.folders.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Folders') is not None:
temp_model = ListParentsResponseBodyFolders()
self.folders = temp_model.from_map(m['Folders'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListParentsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListParentsResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListParentsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListParentsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListPoliciesRequest(TeaModel):
def __init__(self, language=None, page_number=None, page_size=None, policy_type=None):
self.language = language # type: str
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.policy_type = policy_type # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPoliciesRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.language is not None:
result['Language'] = self.language
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
return self
class ListPoliciesResponseBodyPoliciesPolicy(TeaModel):
def __init__(self, attachment_count=None, create_date=None, default_version=None, description=None,
policy_name=None, policy_type=None, update_date=None):
self.attachment_count = attachment_count # type: int
self.create_date = create_date # type: str
self.default_version = default_version # type: str
self.description = description # type: str
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
self.update_date = update_date # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPoliciesResponseBodyPoliciesPolicy, self).to_map()
if _map is not None:
return _map
result = dict()
if self.attachment_count is not None:
result['AttachmentCount'] = self.attachment_count
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.default_version is not None:
result['DefaultVersion'] = self.default_version
if self.description is not None:
result['Description'] = self.description
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
if self.update_date is not None:
result['UpdateDate'] = self.update_date
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AttachmentCount') is not None:
self.attachment_count = m.get('AttachmentCount')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DefaultVersion') is not None:
self.default_version = m.get('DefaultVersion')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
if m.get('UpdateDate') is not None:
self.update_date = m.get('UpdateDate')
return self
class ListPoliciesResponseBodyPolicies(TeaModel):
def __init__(self, policy=None):
self.policy = policy # type: list[ListPoliciesResponseBodyPoliciesPolicy]
def validate(self):
if self.policy:
for k in self.policy:
if k:
k.validate()
def to_map(self):
_map = super(ListPoliciesResponseBodyPolicies, self).to_map()
if _map is not None:
return _map
result = dict()
result['Policy'] = []
if self.policy is not None:
for k in self.policy:
result['Policy'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.policy = []
if m.get('Policy') is not None:
for k in m.get('Policy'):
temp_model = ListPoliciesResponseBodyPoliciesPolicy()
self.policy.append(temp_model.from_map(k))
return self
class ListPoliciesResponseBody(TeaModel):
def __init__(self, page_number=None, page_size=None, policies=None, request_id=None, total_count=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.policies = policies # type: ListPoliciesResponseBodyPolicies
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.policies:
self.policies.validate()
def to_map(self):
_map = super(ListPoliciesResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.policies is not None:
result['Policies'] = self.policies.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Policies') is not None:
temp_model = ListPoliciesResponseBodyPolicies()
self.policies = temp_model.from_map(m['Policies'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListPoliciesResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListPoliciesResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListPoliciesResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListPoliciesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListPolicyAttachmentsRequest(TeaModel):
def __init__(self, account_id=None, language=None, page_number=None, page_size=None, policy_name=None,
policy_type=None, principal_name=None, principal_type=None, resource_group_id=None):
self.account_id = account_id # type: str
self.language = language # type: str
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
self.principal_name = principal_name # type: str
self.principal_type = principal_type # type: str
self.resource_group_id = resource_group_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPolicyAttachmentsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.language is not None:
result['Language'] = self.language
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
if self.principal_name is not None:
result['PrincipalName'] = self.principal_name
if self.principal_type is not None:
result['PrincipalType'] = self.principal_type
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
if m.get('PrincipalName') is not None:
self.principal_name = m.get('PrincipalName')
if m.get('PrincipalType') is not None:
self.principal_type = m.get('PrincipalType')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
return self
class ListPolicyAttachmentsResponseBodyPolicyAttachmentsPolicyAttachment(TeaModel):
def __init__(self, attach_date=None, description=None, policy_name=None, policy_type=None, principal_name=None,
principal_type=None, resource_group_id=None):
self.attach_date = attach_date # type: str
self.description = description # type: str
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
self.principal_name = principal_name # type: str
self.principal_type = principal_type # type: str
self.resource_group_id = resource_group_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPolicyAttachmentsResponseBodyPolicyAttachmentsPolicyAttachment, self).to_map()
if _map is not None:
return _map
result = dict()
if self.attach_date is not None:
result['AttachDate'] = self.attach_date
if self.description is not None:
result['Description'] = self.description
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
if self.principal_name is not None:
result['PrincipalName'] = self.principal_name
if self.principal_type is not None:
result['PrincipalType'] = self.principal_type
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AttachDate') is not None:
self.attach_date = m.get('AttachDate')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
if m.get('PrincipalName') is not None:
self.principal_name = m.get('PrincipalName')
if m.get('PrincipalType') is not None:
self.principal_type = m.get('PrincipalType')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
return self
class ListPolicyAttachmentsResponseBodyPolicyAttachments(TeaModel):
def __init__(self, policy_attachment=None):
self.policy_attachment = policy_attachment # type: list[ListPolicyAttachmentsResponseBodyPolicyAttachmentsPolicyAttachment]
def validate(self):
if self.policy_attachment:
for k in self.policy_attachment:
if k:
k.validate()
def to_map(self):
_map = super(ListPolicyAttachmentsResponseBodyPolicyAttachments, self).to_map()
if _map is not None:
return _map
result = dict()
result['PolicyAttachment'] = []
if self.policy_attachment is not None:
for k in self.policy_attachment:
result['PolicyAttachment'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.policy_attachment = []
if m.get('PolicyAttachment') is not None:
for k in m.get('PolicyAttachment'):
temp_model = ListPolicyAttachmentsResponseBodyPolicyAttachmentsPolicyAttachment()
self.policy_attachment.append(temp_model.from_map(k))
return self
class ListPolicyAttachmentsResponseBody(TeaModel):
def __init__(self, page_number=None, page_size=None, policy_attachments=None, request_id=None, total_count=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.policy_attachments = policy_attachments # type: ListPolicyAttachmentsResponseBodyPolicyAttachments
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.policy_attachments:
self.policy_attachments.validate()
def to_map(self):
_map = super(ListPolicyAttachmentsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.policy_attachments is not None:
result['PolicyAttachments'] = self.policy_attachments.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PolicyAttachments') is not None:
temp_model = ListPolicyAttachmentsResponseBodyPolicyAttachments()
self.policy_attachments = temp_model.from_map(m['PolicyAttachments'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListPolicyAttachmentsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListPolicyAttachmentsResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListPolicyAttachmentsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListPolicyAttachmentsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListPolicyVersionsRequest(TeaModel):
def __init__(self, policy_name=None, policy_type=None):
self.policy_name = policy_name # type: str
self.policy_type = policy_type # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPolicyVersionsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.policy_type is not None:
result['PolicyType'] = self.policy_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('PolicyType') is not None:
self.policy_type = m.get('PolicyType')
return self
class ListPolicyVersionsResponseBodyPolicyVersionsPolicyVersion(TeaModel):
def __init__(self, create_date=None, is_default_version=None, version_id=None):
self.create_date = create_date # type: str
self.is_default_version = is_default_version # type: bool
self.version_id = version_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPolicyVersionsResponseBodyPolicyVersionsPolicyVersion, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.is_default_version is not None:
result['IsDefaultVersion'] = self.is_default_version
if self.version_id is not None:
result['VersionId'] = self.version_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('IsDefaultVersion') is not None:
self.is_default_version = m.get('IsDefaultVersion')
if m.get('VersionId') is not None:
self.version_id = m.get('VersionId')
return self
class ListPolicyVersionsResponseBodyPolicyVersions(TeaModel):
def __init__(self, policy_version=None):
self.policy_version = policy_version # type: list[ListPolicyVersionsResponseBodyPolicyVersionsPolicyVersion]
def validate(self):
if self.policy_version:
for k in self.policy_version:
if k:
k.validate()
def to_map(self):
_map = super(ListPolicyVersionsResponseBodyPolicyVersions, self).to_map()
if _map is not None:
return _map
result = dict()
result['PolicyVersion'] = []
if self.policy_version is not None:
for k in self.policy_version:
result['PolicyVersion'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.policy_version = []
if m.get('PolicyVersion') is not None:
for k in m.get('PolicyVersion'):
temp_model = ListPolicyVersionsResponseBodyPolicyVersionsPolicyVersion()
self.policy_version.append(temp_model.from_map(k))
return self
class ListPolicyVersionsResponseBody(TeaModel):
def __init__(self, policy_versions=None, request_id=None):
self.policy_versions = policy_versions # type: ListPolicyVersionsResponseBodyPolicyVersions
self.request_id = request_id # type: str
def validate(self):
if self.policy_versions:
self.policy_versions.validate()
def to_map(self):
_map = super(ListPolicyVersionsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_versions is not None:
result['PolicyVersions'] = self.policy_versions.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyVersions') is not None:
temp_model = ListPolicyVersionsResponseBodyPolicyVersions()
self.policy_versions = temp_model.from_map(m['PolicyVersions'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListPolicyVersionsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListPolicyVersionsResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListPolicyVersionsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListPolicyVersionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListResourceGroupsRequest(TeaModel):
def __init__(self, account_id=None, page_number=None, page_size=None, status=None):
self.account_id = account_id # type: str
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.status = status # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListResourceGroupsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class ListResourceGroupsResponseBodyResourceGroupsResourceGroup(TeaModel):
def __init__(self, account_id=None, create_date=None, display_name=None, id=None, name=None, status=None):
self.account_id = account_id # type: str
self.create_date = create_date # type: str
self.display_name = display_name # type: str
self.id = id # type: str
self.name = name # type: str
self.status = status # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListResourceGroupsResponseBodyResourceGroupsResourceGroup, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.id is not None:
result['Id'] = self.id
if self.name is not None:
result['Name'] = self.name
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class ListResourceGroupsResponseBodyResourceGroups(TeaModel):
def __init__(self, resource_group=None):
self.resource_group = resource_group # type: list[ListResourceGroupsResponseBodyResourceGroupsResourceGroup]
def validate(self):
if self.resource_group:
for k in self.resource_group:
if k:
k.validate()
def to_map(self):
_map = super(ListResourceGroupsResponseBodyResourceGroups, self).to_map()
if _map is not None:
return _map
result = dict()
result['ResourceGroup'] = []
if self.resource_group is not None:
for k in self.resource_group:
result['ResourceGroup'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.resource_group = []
if m.get('ResourceGroup') is not None:
for k in m.get('ResourceGroup'):
temp_model = ListResourceGroupsResponseBodyResourceGroupsResourceGroup()
self.resource_group.append(temp_model.from_map(k))
return self
class ListResourceGroupsResponseBody(TeaModel):
def __init__(self, page_number=None, page_size=None, request_id=None, resource_groups=None, total_count=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.request_id = request_id # type: str
self.resource_groups = resource_groups # type: ListResourceGroupsResponseBodyResourceGroups
self.total_count = total_count # type: int
def validate(self):
if self.resource_groups:
self.resource_groups.validate()
def to_map(self):
_map = super(ListResourceGroupsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_groups is not None:
result['ResourceGroups'] = self.resource_groups.to_map()
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceGroups') is not None:
temp_model = ListResourceGroupsResponseBodyResourceGroups()
self.resource_groups = temp_model.from_map(m['ResourceGroups'])
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListResourceGroupsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListResourceGroupsResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListResourceGroupsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListResourceGroupsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListRolesRequest(TeaModel):
def __init__(self, language=None, page_number=None, page_size=None):
self.language = language # type: str
self.page_number = page_number # type: int
self.page_size = page_size # type: int
def validate(self):
pass
def to_map(self):
_map = super(ListRolesRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.language is not None:
result['Language'] = self.language
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListRolesResponseBodyRolesRoleLatestDeletionTask(TeaModel):
def __init__(self, create_date=None, deletion_task_id=None):
self.create_date = create_date # type: str
self.deletion_task_id = deletion_task_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListRolesResponseBodyRolesRoleLatestDeletionTask, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.deletion_task_id is not None:
result['DeletionTaskId'] = self.deletion_task_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DeletionTaskId') is not None:
self.deletion_task_id = m.get('DeletionTaskId')
return self
class ListRolesResponseBodyRolesRole(TeaModel):
def __init__(self, arn=None, create_date=None, description=None, is_service_linked_role=None,
latest_deletion_task=None, max_session_duration=None, role_id=None, role_name=None, role_principal_name=None,
update_date=None):
self.arn = arn # type: str
self.create_date = create_date # type: str
self.description = description # type: str
self.is_service_linked_role = is_service_linked_role # type: bool
self.latest_deletion_task = latest_deletion_task # type: ListRolesResponseBodyRolesRoleLatestDeletionTask
self.max_session_duration = max_session_duration # type: long
self.role_id = role_id # type: str
self.role_name = role_name # type: str
self.role_principal_name = role_principal_name # type: str
self.update_date = update_date # type: str
def validate(self):
if self.latest_deletion_task:
self.latest_deletion_task.validate()
def to_map(self):
_map = super(ListRolesResponseBodyRolesRole, self).to_map()
if _map is not None:
return _map
result = dict()
if self.arn is not None:
result['Arn'] = self.arn
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.description is not None:
result['Description'] = self.description
if self.is_service_linked_role is not None:
result['IsServiceLinkedRole'] = self.is_service_linked_role
if self.latest_deletion_task is not None:
result['LatestDeletionTask'] = self.latest_deletion_task.to_map()
if self.max_session_duration is not None:
result['MaxSessionDuration'] = self.max_session_duration
if self.role_id is not None:
result['RoleId'] = self.role_id
if self.role_name is not None:
result['RoleName'] = self.role_name
if self.role_principal_name is not None:
result['RolePrincipalName'] = self.role_principal_name
if self.update_date is not None:
result['UpdateDate'] = self.update_date
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Arn') is not None:
self.arn = m.get('Arn')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('IsServiceLinkedRole') is not None:
self.is_service_linked_role = m.get('IsServiceLinkedRole')
if m.get('LatestDeletionTask') is not None:
temp_model = ListRolesResponseBodyRolesRoleLatestDeletionTask()
self.latest_deletion_task = temp_model.from_map(m['LatestDeletionTask'])
if m.get('MaxSessionDuration') is not None:
self.max_session_duration = m.get('MaxSessionDuration')
if m.get('RoleId') is not None:
self.role_id = m.get('RoleId')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
if m.get('RolePrincipalName') is not None:
self.role_principal_name = m.get('RolePrincipalName')
if m.get('UpdateDate') is not None:
self.update_date = m.get('UpdateDate')
return self
class ListRolesResponseBodyRoles(TeaModel):
def __init__(self, role=None):
self.role = role # type: list[ListRolesResponseBodyRolesRole]
def validate(self):
if self.role:
for k in self.role:
if k:
k.validate()
def to_map(self):
_map = super(ListRolesResponseBodyRoles, self).to_map()
if _map is not None:
return _map
result = dict()
result['Role'] = []
if self.role is not None:
for k in self.role:
result['Role'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.role = []
if m.get('Role') is not None:
for k in m.get('Role'):
temp_model = ListRolesResponseBodyRolesRole()
self.role.append(temp_model.from_map(k))
return self
class ListRolesResponseBody(TeaModel):
def __init__(self, page_number=None, page_size=None, request_id=None, roles=None, total_count=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.request_id = request_id # type: str
self.roles = roles # type: ListRolesResponseBodyRoles
self.total_count = total_count # type: int
def validate(self):
if self.roles:
self.roles.validate()
def to_map(self):
_map = super(ListRolesResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.roles is not None:
result['Roles'] = self.roles.to_map()
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Roles') is not None:
temp_model = ListRolesResponseBodyRoles()
self.roles = temp_model.from_map(m['Roles'])
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListRolesResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListRolesResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListRolesResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListRolesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListRolesForServiceRequest(TeaModel):
def __init__(self, language=None, service=None):
self.language = language # type: str
self.service = service # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListRolesForServiceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.language is not None:
result['Language'] = self.language
if self.service is not None:
result['Service'] = self.service
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('Service') is not None:
self.service = m.get('Service')
return self
class ListRolesForServiceResponseBodyRolesRoleLatestDeletionTask(TeaModel):
def __init__(self, create_date=None, deletion_task_id=None):
self.create_date = create_date # type: str
self.deletion_task_id = deletion_task_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListRolesForServiceResponseBodyRolesRoleLatestDeletionTask, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.deletion_task_id is not None:
result['DeletionTaskId'] = self.deletion_task_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DeletionTaskId') is not None:
self.deletion_task_id = m.get('DeletionTaskId')
return self
class ListRolesForServiceResponseBodyRolesRole(TeaModel):
def __init__(self, arn=None, create_date=None, description=None, is_service_linked_role=None,
latest_deletion_task=None, max_session_duration=None, role_id=None, role_name=None, role_principal_name=None,
update_date=None):
self.arn = arn # type: str
self.create_date = create_date # type: str
self.description = description # type: str
self.is_service_linked_role = is_service_linked_role # type: bool
self.latest_deletion_task = latest_deletion_task # type: ListRolesForServiceResponseBodyRolesRoleLatestDeletionTask
self.max_session_duration = max_session_duration # type: long
self.role_id = role_id # type: str
self.role_name = role_name # type: str
self.role_principal_name = role_principal_name # type: str
self.update_date = update_date # type: str
def validate(self):
if self.latest_deletion_task:
self.latest_deletion_task.validate()
def to_map(self):
_map = super(ListRolesForServiceResponseBodyRolesRole, self).to_map()
if _map is not None:
return _map
result = dict()
if self.arn is not None:
result['Arn'] = self.arn
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.description is not None:
result['Description'] = self.description
if self.is_service_linked_role is not None:
result['IsServiceLinkedRole'] = self.is_service_linked_role
if self.latest_deletion_task is not None:
result['LatestDeletionTask'] = self.latest_deletion_task.to_map()
if self.max_session_duration is not None:
result['MaxSessionDuration'] = self.max_session_duration
if self.role_id is not None:
result['RoleId'] = self.role_id
if self.role_name is not None:
result['RoleName'] = self.role_name
if self.role_principal_name is not None:
result['RolePrincipalName'] = self.role_principal_name
if self.update_date is not None:
result['UpdateDate'] = self.update_date
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Arn') is not None:
self.arn = m.get('Arn')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('IsServiceLinkedRole') is not None:
self.is_service_linked_role = m.get('IsServiceLinkedRole')
if m.get('LatestDeletionTask') is not None:
temp_model = ListRolesForServiceResponseBodyRolesRoleLatestDeletionTask()
self.latest_deletion_task = temp_model.from_map(m['LatestDeletionTask'])
if m.get('MaxSessionDuration') is not None:
self.max_session_duration = m.get('MaxSessionDuration')
if m.get('RoleId') is not None:
self.role_id = m.get('RoleId')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
if m.get('RolePrincipalName') is not None:
self.role_principal_name = m.get('RolePrincipalName')
if m.get('UpdateDate') is not None:
self.update_date = m.get('UpdateDate')
return self
class ListRolesForServiceResponseBodyRoles(TeaModel):
def __init__(self, role=None):
self.role = role # type: list[ListRolesForServiceResponseBodyRolesRole]
def validate(self):
if self.role:
for k in self.role:
if k:
k.validate()
def to_map(self):
_map = super(ListRolesForServiceResponseBodyRoles, self).to_map()
if _map is not None:
return _map
result = dict()
result['Role'] = []
if self.role is not None:
for k in self.role:
result['Role'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.role = []
if m.get('Role') is not None:
for k in m.get('Role'):
temp_model = ListRolesForServiceResponseBodyRolesRole()
self.role.append(temp_model.from_map(k))
return self
class ListRolesForServiceResponseBody(TeaModel):
def __init__(self, request_id=None, roles=None):
self.request_id = request_id # type: str
self.roles = roles # type: ListRolesForServiceResponseBodyRoles
def validate(self):
if self.roles:
self.roles.validate()
def to_map(self):
_map = super(ListRolesForServiceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.roles is not None:
result['Roles'] = self.roles.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Roles') is not None:
temp_model = ListRolesForServiceResponseBodyRoles()
self.roles = temp_model.from_map(m['Roles'])
return self
class ListRolesForServiceResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListRolesForServiceResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListRolesForServiceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListRolesForServiceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListTrustedServiceStatusRequest(TeaModel):
def __init__(self, page_number=None, page_size=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
def validate(self):
pass
def to_map(self):
_map = super(ListTrustedServiceStatusRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListTrustedServiceStatusResponseBodyEnabledServicePrincipalsEnabledServicePrincipal(TeaModel):
def __init__(self, enable_time=None, service_principal=None):
self.enable_time = enable_time # type: str
self.service_principal = service_principal # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListTrustedServiceStatusResponseBodyEnabledServicePrincipalsEnabledServicePrincipal, self).to_map()
if _map is not None:
return _map
result = dict()
if self.enable_time is not None:
result['EnableTime'] = self.enable_time
if self.service_principal is not None:
result['ServicePrincipal'] = self.service_principal
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnableTime') is not None:
self.enable_time = m.get('EnableTime')
if m.get('ServicePrincipal') is not None:
self.service_principal = m.get('ServicePrincipal')
return self
class ListTrustedServiceStatusResponseBodyEnabledServicePrincipals(TeaModel):
def __init__(self, enabled_service_principal=None):
self.enabled_service_principal = enabled_service_principal # type: list[ListTrustedServiceStatusResponseBodyEnabledServicePrincipalsEnabledServicePrincipal]
def validate(self):
if self.enabled_service_principal:
for k in self.enabled_service_principal:
if k:
k.validate()
def to_map(self):
_map = super(ListTrustedServiceStatusResponseBodyEnabledServicePrincipals, self).to_map()
if _map is not None:
return _map
result = dict()
result['EnabledServicePrincipal'] = []
if self.enabled_service_principal is not None:
for k in self.enabled_service_principal:
result['EnabledServicePrincipal'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.enabled_service_principal = []
if m.get('EnabledServicePrincipal') is not None:
for k in m.get('EnabledServicePrincipal'):
temp_model = ListTrustedServiceStatusResponseBodyEnabledServicePrincipalsEnabledServicePrincipal()
self.enabled_service_principal.append(temp_model.from_map(k))
return self
class ListTrustedServiceStatusResponseBody(TeaModel):
def __init__(self, enabled_service_principals=None, page_number=None, page_size=None, request_id=None,
total_count=None):
self.enabled_service_principals = enabled_service_principals # type: ListTrustedServiceStatusResponseBodyEnabledServicePrincipals
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.enabled_service_principals:
self.enabled_service_principals.validate()
def to_map(self):
_map = super(ListTrustedServiceStatusResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.enabled_service_principals is not None:
result['EnabledServicePrincipals'] = self.enabled_service_principals.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnabledServicePrincipals') is not None:
temp_model = ListTrustedServiceStatusResponseBodyEnabledServicePrincipals()
self.enabled_service_principals = temp_model.from_map(m['EnabledServicePrincipals'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListTrustedServiceStatusResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListTrustedServiceStatusResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListTrustedServiceStatusResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListTrustedServiceStatusResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class MoveAccountRequest(TeaModel):
def __init__(self, account_id=None, destination_folder_id=None):
self.account_id = account_id # type: str
self.destination_folder_id = destination_folder_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(MoveAccountRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.destination_folder_id is not None:
result['DestinationFolderId'] = self.destination_folder_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('DestinationFolderId') is not None:
self.destination_folder_id = m.get('DestinationFolderId')
return self
class MoveAccountResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(MoveAccountResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class MoveAccountResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: MoveAccountResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(MoveAccountResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = MoveAccountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class PromoteResourceAccountRequest(TeaModel):
def __init__(self, account_id=None, email=None):
self.account_id = account_id # type: str
self.email = email # type: str
def validate(self):
pass
def to_map(self):
_map = super(PromoteResourceAccountRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.email is not None:
result['Email'] = self.email
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('Email') is not None:
self.email = m.get('Email')
return self
class PromoteResourceAccountResponseBody(TeaModel):
def __init__(self, record_id=None, request_id=None):
self.record_id = record_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(PromoteResourceAccountResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.record_id is not None:
result['RecordId'] = self.record_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class PromoteResourceAccountResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: PromoteResourceAccountResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(PromoteResourceAccountResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = PromoteResourceAccountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class QueryResourceRequest(TeaModel):
def __init__(self, account_id=None, page_number=None, page_size=None, region=None, resource_group_id=None,
resource_id=None, resource_type=None, service=None):
self.account_id = account_id # type: str
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.region = region # type: str
self.resource_group_id = resource_group_id # type: str
self.resource_id = resource_id # type: str
self.resource_type = resource_type # type: str
self.service = service # type: str
def validate(self):
pass
def to_map(self):
_map = super(QueryResourceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.region is not None:
result['Region'] = self.region
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.resource_type is not None:
result['ResourceType'] = self.resource_type
if self.service is not None:
result['Service'] = self.service
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('ResourceType') is not None:
self.resource_type = m.get('ResourceType')
if m.get('Service') is not None:
self.service = m.get('Service')
return self
class QueryResourceResponseBodyResourcesResource(TeaModel):
def __init__(self, create_date=None, region_id=None, resource_group_id=None, resource_id=None,
resource_type=None, service=None):
self.create_date = create_date # type: str
self.region_id = region_id # type: str
self.resource_group_id = resource_group_id # type: str
self.resource_id = resource_id # type: str
self.resource_type = resource_type # type: str
self.service = service # type: str
def validate(self):
pass
def to_map(self):
_map = super(QueryResourceResponseBodyResourcesResource, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.resource_type is not None:
result['ResourceType'] = self.resource_type
if self.service is not None:
result['Service'] = self.service
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('ResourceType') is not None:
self.resource_type = m.get('ResourceType')
if m.get('Service') is not None:
self.service = m.get('Service')
return self
class QueryResourceResponseBodyResources(TeaModel):
def __init__(self, resource=None):
self.resource = resource # type: list[QueryResourceResponseBodyResourcesResource]
def validate(self):
if self.resource:
for k in self.resource:
if k:
k.validate()
def to_map(self):
_map = super(QueryResourceResponseBodyResources, self).to_map()
if _map is not None:
return _map
result = dict()
result['Resource'] = []
if self.resource is not None:
for k in self.resource:
result['Resource'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.resource = []
if m.get('Resource') is not None:
for k in m.get('Resource'):
temp_model = QueryResourceResponseBodyResourcesResource()
self.resource.append(temp_model.from_map(k))
return self
class QueryResourceResponseBody(TeaModel):
def __init__(self, page_number=None, page_size=None, request_id=None, resources=None, total_count=None):
self.page_number = page_number # type: int
self.page_size = page_size # type: int
self.request_id = request_id # type: str
self.resources = resources # type: QueryResourceResponseBodyResources
self.total_count = total_count # type: int
def validate(self):
if self.resources:
self.resources.validate()
def to_map(self):
_map = super(QueryResourceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resources is not None:
result['Resources'] = self.resources.to_map()
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Resources') is not None:
temp_model = QueryResourceResponseBodyResources()
self.resources = temp_model.from_map(m['Resources'])
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class QueryResourceResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: QueryResourceResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(QueryResourceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = QueryResourceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RemoveCloudAccountRequest(TeaModel):
def __init__(self, account_id=None):
self.account_id = account_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(RemoveCloudAccountRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
return self
class RemoveCloudAccountResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(RemoveCloudAccountResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RemoveCloudAccountResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: RemoveCloudAccountResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RemoveCloudAccountResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = RemoveCloudAccountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ResendCreateCloudAccountEmailRequest(TeaModel):
def __init__(self, record_id=None):
self.record_id = record_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ResendCreateCloudAccountEmailRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.record_id is not None:
result['RecordId'] = self.record_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
return self
class ResendCreateCloudAccountEmailResponseBody(TeaModel):
def __init__(self, record_id=None, request_id=None):
self.record_id = record_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ResendCreateCloudAccountEmailResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.record_id is not None:
result['RecordId'] = self.record_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ResendCreateCloudAccountEmailResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ResendCreateCloudAccountEmailResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ResendCreateCloudAccountEmailResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ResendCreateCloudAccountEmailResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ResendPromoteResourceAccountEmailRequest(TeaModel):
def __init__(self, record_id=None):
self.record_id = record_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ResendPromoteResourceAccountEmailRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.record_id is not None:
result['RecordId'] = self.record_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
return self
class ResendPromoteResourceAccountEmailResponseBody(TeaModel):
def __init__(self, record_id=None, request_id=None):
self.record_id = record_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ResendPromoteResourceAccountEmailResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.record_id is not None:
result['RecordId'] = self.record_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ResendPromoteResourceAccountEmailResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ResendPromoteResourceAccountEmailResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(ResendPromoteResourceAccountEmailResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ResendPromoteResourceAccountEmailResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class SetDefaultPolicyVersionRequest(TeaModel):
def __init__(self, policy_name=None, version_id=None):
self.policy_name = policy_name # type: str
self.version_id = version_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(SetDefaultPolicyVersionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.policy_name is not None:
result['PolicyName'] = self.policy_name
if self.version_id is not None:
result['VersionId'] = self.version_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PolicyName') is not None:
self.policy_name = m.get('PolicyName')
if m.get('VersionId') is not None:
self.version_id = m.get('VersionId')
return self
class SetDefaultPolicyVersionResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(SetDefaultPolicyVersionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class SetDefaultPolicyVersionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: SetDefaultPolicyVersionResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(SetDefaultPolicyVersionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = SetDefaultPolicyVersionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateFolderRequest(TeaModel):
def __init__(self, folder_id=None, name=None):
self.folder_id = folder_id # type: str
self.name = name # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateFolderRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.folder_id is not None:
result['FolderId'] = self.folder_id
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FolderId') is not None:
self.folder_id = m.get('FolderId')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class UpdateFolderResponseBody(TeaModel):
def __init__(self, request_id=None):
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateFolderResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class UpdateFolderResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: UpdateFolderResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(UpdateFolderResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UpdateFolderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateResourceGroupRequest(TeaModel):
def __init__(self, account_id=None, new_display_name=None, resource_group_id=None):
self.account_id = account_id # type: str
self.new_display_name = new_display_name # type: str
self.resource_group_id = resource_group_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateResourceGroupRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.new_display_name is not None:
result['NewDisplayName'] = self.new_display_name
if self.resource_group_id is not None:
result['ResourceGroupId'] = self.resource_group_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('NewDisplayName') is not None:
self.new_display_name = m.get('NewDisplayName')
if m.get('ResourceGroupId') is not None:
self.resource_group_id = m.get('ResourceGroupId')
return self
class UpdateResourceGroupResponseBodyResourceGroup(TeaModel):
def __init__(self, account_id=None, create_date=None, display_name=None, id=None, name=None):
self.account_id = account_id # type: str
self.create_date = create_date # type: str
self.display_name = display_name # type: str
self.id = id # type: str
self.name = name # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateResourceGroupResponseBodyResourceGroup, self).to_map()
if _map is not None:
return _map
result = dict()
if self.account_id is not None:
result['AccountId'] = self.account_id
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.display_name is not None:
result['DisplayName'] = self.display_name
if self.id is not None:
result['Id'] = self.id
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AccountId') is not None:
self.account_id = m.get('AccountId')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('DisplayName') is not None:
self.display_name = m.get('DisplayName')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class UpdateResourceGroupResponseBody(TeaModel):
def __init__(self, request_id=None, resource_group=None):
self.request_id = request_id # type: str
self.resource_group = resource_group # type: UpdateResourceGroupResponseBodyResourceGroup
def validate(self):
if self.resource_group:
self.resource_group.validate()
def to_map(self):
_map = super(UpdateResourceGroupResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_group is not None:
result['ResourceGroup'] = self.resource_group.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceGroup') is not None:
temp_model = UpdateResourceGroupResponseBodyResourceGroup()
self.resource_group = temp_model.from_map(m['ResourceGroup'])
return self
class UpdateResourceGroupResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: UpdateResourceGroupResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(UpdateResourceGroupResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UpdateResourceGroupResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateRoleRequest(TeaModel):
def __init__(self, new_assume_role_policy_document=None, new_description=None, new_max_session_duration=None,
role_name=None):
self.new_assume_role_policy_document = new_assume_role_policy_document # type: str
self.new_description = new_description # type: str
self.new_max_session_duration = new_max_session_duration # type: long
self.role_name = role_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateRoleRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.new_assume_role_policy_document is not None:
result['NewAssumeRolePolicyDocument'] = self.new_assume_role_policy_document
if self.new_description is not None:
result['NewDescription'] = self.new_description
if self.new_max_session_duration is not None:
result['NewMaxSessionDuration'] = self.new_max_session_duration
if self.role_name is not None:
result['RoleName'] = self.role_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('NewAssumeRolePolicyDocument') is not None:
self.new_assume_role_policy_document = m.get('NewAssumeRolePolicyDocument')
if m.get('NewDescription') is not None:
self.new_description = m.get('NewDescription')
if m.get('NewMaxSessionDuration') is not None:
self.new_max_session_duration = m.get('NewMaxSessionDuration')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
return self
class UpdateRoleResponseBodyRole(TeaModel):
def __init__(self, arn=None, assume_role_policy_document=None, create_date=None, description=None,
max_session_duration=None, role_id=None, role_name=None, role_principal_name=None, update_date=None):
self.arn = arn # type: str
self.assume_role_policy_document = assume_role_policy_document # type: str
self.create_date = create_date # type: str
self.description = description # type: str
self.max_session_duration = max_session_duration # type: long
self.role_id = role_id # type: str
self.role_name = role_name # type: str
self.role_principal_name = role_principal_name # type: str
self.update_date = update_date # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateRoleResponseBodyRole, self).to_map()
if _map is not None:
return _map
result = dict()
if self.arn is not None:
result['Arn'] = self.arn
if self.assume_role_policy_document is not None:
result['AssumeRolePolicyDocument'] = self.assume_role_policy_document
if self.create_date is not None:
result['CreateDate'] = self.create_date
if self.description is not None:
result['Description'] = self.description
if self.max_session_duration is not None:
result['MaxSessionDuration'] = self.max_session_duration
if self.role_id is not None:
result['RoleId'] = self.role_id
if self.role_name is not None:
result['RoleName'] = self.role_name
if self.role_principal_name is not None:
result['RolePrincipalName'] = self.role_principal_name
if self.update_date is not None:
result['UpdateDate'] = self.update_date
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Arn') is not None:
self.arn = m.get('Arn')
if m.get('AssumeRolePolicyDocument') is not None:
self.assume_role_policy_document = m.get('AssumeRolePolicyDocument')
if m.get('CreateDate') is not None:
self.create_date = m.get('CreateDate')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('MaxSessionDuration') is not None:
self.max_session_duration = m.get('MaxSessionDuration')
if m.get('RoleId') is not None:
self.role_id = m.get('RoleId')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
if m.get('RolePrincipalName') is not None:
self.role_principal_name = m.get('RolePrincipalName')
if m.get('UpdateDate') is not None:
self.update_date = m.get('UpdateDate')
return self
class UpdateRoleResponseBody(TeaModel):
def __init__(self, request_id=None, role=None):
self.request_id = request_id # type: str
self.role = role # type: UpdateRoleResponseBodyRole
def validate(self):
if self.role:
self.role.validate()
def to_map(self):
_map = super(UpdateRoleResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.role is not None:
result['Role'] = self.role.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Role') is not None:
temp_model = UpdateRoleResponseBodyRole()
self.role = temp_model.from_map(m['Role'])
return self
class UpdateRoleResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: UpdateRoleResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(UpdateRoleResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UpdateRoleResponseBody()
self.body = temp_model.from_map(m['body'])
return self