alibabacloud-ecd20201002 1.1.6__py3-none-any.whl → 1.2.0__py3-none-any.whl

alibabacloud_ecd20201002/models.py

@@ -2231,6 +2231,953 @@ class DescribeSnapshotsResponse(TeaModel):
         return self
 
 
+class DescribeUserResourcesRequest(TeaModel):
+    def __init__(
+        self,
+        access_type: str = None,
+        auto_refresh: bool = None,
+        category_id: int = None,
+        category_type: int = None,
+        client_id: str = None,
+        client_type: str = None,
+        client_version: str = None,
+        dual_center_forward: bool = None,
+        language: str = None,
+        login_region_id: str = None,
+        login_token: str = None,
+        max_results: int = None,
+        next_token: str = None,
+        office_site_ids: List[str] = None,
+        order_by: str = None,
+        product_types: List[str] = None,
+        protocol_type: str = None,
+        query_fota_update: bool = None,
+        refresh_fota_update: bool = None,
+        resource_ids: List[str] = None,
+        resource_name: str = None,
+        resource_types: List[str] = None,
+        scene: str = None,
+        search_region_id: str = None,
+        session_id: str = None,
+        sort_type: str = None,
+    ):
+        self.access_type = access_type
+        self.auto_refresh = auto_refresh
+        self.category_id = category_id
+        self.category_type = category_type
+        # This parameter is required.
+        self.client_id = client_id
+        self.client_type = client_type
+        self.client_version = client_version
+        self.dual_center_forward = dual_center_forward
+        self.language = language
+        self.login_region_id = login_region_id
+        # This parameter is required.
+        self.login_token = login_token
+        self.max_results = max_results
+        self.next_token = next_token
+        self.office_site_ids = office_site_ids
+        self.order_by = order_by
+        self.product_types = product_types
+        self.protocol_type = protocol_type
+        self.query_fota_update = query_fota_update
+        self.refresh_fota_update = refresh_fota_update
+        self.resource_ids = resource_ids
+        self.resource_name = resource_name
+        self.resource_types = resource_types
+        self.scene = scene
+        self.search_region_id = search_region_id
+        self.session_id = session_id
+        self.sort_type = sort_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.access_type is not None:
+            result['AccessType'] = self.access_type
+        if self.auto_refresh is not None:
+            result['AutoRefresh'] = self.auto_refresh
+        if self.category_id is not None:
+            result['CategoryId'] = self.category_id
+        if self.category_type is not None:
+            result['CategoryType'] = self.category_type
+        if self.client_id is not None:
+            result['ClientId'] = self.client_id
+        if self.client_type is not None:
+            result['ClientType'] = self.client_type
+        if self.client_version is not None:
+            result['ClientVersion'] = self.client_version
+        if self.dual_center_forward is not None:
+            result['DualCenterForward'] = self.dual_center_forward
+        if self.language is not None:
+            result['Language'] = self.language
+        if self.login_region_id is not None:
+            result['LoginRegionId'] = self.login_region_id
+        if self.login_token is not None:
+            result['LoginToken'] = self.login_token
+        if self.max_results is not None:
+            result['MaxResults'] = self.max_results
+        if self.next_token is not None:
+            result['NextToken'] = self.next_token
+        if self.office_site_ids is not None:
+            result['OfficeSiteIds'] = self.office_site_ids
+        if self.order_by is not None:
+            result['OrderBy'] = self.order_by
+        if self.product_types is not None:
+            result['ProductTypes'] = self.product_types
+        if self.protocol_type is not None:
+            result['ProtocolType'] = self.protocol_type
+        if self.query_fota_update is not None:
+            result['QueryFotaUpdate'] = self.query_fota_update
+        if self.refresh_fota_update is not None:
+            result['RefreshFotaUpdate'] = self.refresh_fota_update
+        if self.resource_ids is not None:
+            result['ResourceIds'] = self.resource_ids
+        if self.resource_name is not None:
+            result['ResourceName'] = self.resource_name
+        if self.resource_types is not None:
+            result['ResourceTypes'] = self.resource_types
+        if self.scene is not None:
+            result['Scene'] = self.scene
+        if self.search_region_id is not None:
+            result['SearchRegionId'] = self.search_region_id
+        if self.session_id is not None:
+            result['SessionId'] = self.session_id
+        if self.sort_type is not None:
+            result['SortType'] = self.sort_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AccessType') is not None:
+            self.access_type = m.get('AccessType')
+        if m.get('AutoRefresh') is not None:
+            self.auto_refresh = m.get('AutoRefresh')
+        if m.get('CategoryId') is not None:
+            self.category_id = m.get('CategoryId')
+        if m.get('CategoryType') is not None:
+            self.category_type = m.get('CategoryType')
+        if m.get('ClientId') is not None:
+            self.client_id = m.get('ClientId')
+        if m.get('ClientType') is not None:
+            self.client_type = m.get('ClientType')
+        if m.get('ClientVersion') is not None:
+            self.client_version = m.get('ClientVersion')
+        if m.get('DualCenterForward') is not None:
+            self.dual_center_forward = m.get('DualCenterForward')
+        if m.get('Language') is not None:
+            self.language = m.get('Language')
+        if m.get('LoginRegionId') is not None:
+            self.login_region_id = m.get('LoginRegionId')
+        if m.get('LoginToken') is not None:
+            self.login_token = m.get('LoginToken')
+        if m.get('MaxResults') is not None:
+            self.max_results = m.get('MaxResults')
+        if m.get('NextToken') is not None:
+            self.next_token = m.get('NextToken')
+        if m.get('OfficeSiteIds') is not None:
+            self.office_site_ids = m.get('OfficeSiteIds')
+        if m.get('OrderBy') is not None:
+            self.order_by = m.get('OrderBy')
+        if m.get('ProductTypes') is not None:
+            self.product_types = m.get('ProductTypes')
+        if m.get('ProtocolType') is not None:
+            self.protocol_type = m.get('ProtocolType')
+        if m.get('QueryFotaUpdate') is not None:
+            self.query_fota_update = m.get('QueryFotaUpdate')
+        if m.get('RefreshFotaUpdate') is not None:
+            self.refresh_fota_update = m.get('RefreshFotaUpdate')
+        if m.get('ResourceIds') is not None:
+            self.resource_ids = m.get('ResourceIds')
+        if m.get('ResourceName') is not None:
+            self.resource_name = m.get('ResourceName')
+        if m.get('ResourceTypes') is not None:
+            self.resource_types = m.get('ResourceTypes')
+        if m.get('Scene') is not None:
+            self.scene = m.get('Scene')
+        if m.get('SearchRegionId') is not None:
+            self.search_region_id = m.get('SearchRegionId')
+        if m.get('SessionId') is not None:
+            self.session_id = m.get('SessionId')
+        if m.get('SortType') is not None:
+            self.sort_type = m.get('SortType')
+        return self
+
+
+class DescribeUserResourcesResponseBodyResourcesClients(TeaModel):
+    def __init__(
+        self,
+        client_type: str = None,
+        status: str = None,
+    ):
+        self.client_type = client_type
+        self.status = status
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.client_type is not None:
+            result['ClientType'] = self.client_type
+        if self.status is not None:
+            result['Status'] = self.status
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ClientType') is not None:
+            self.client_type = m.get('ClientType')
+        if m.get('Status') is not None:
+            self.status = m.get('Status')
+        return self
+
+
+class DescribeUserResourcesResponseBodyResourcesDesktopDurationList(TeaModel):
+    def __init__(
+        self,
+        order_instance_id: str = None,
+        package_creation_time: str = None,
+        package_expired_time: str = None,
+        package_id: str = None,
+        package_status: str = None,
+        package_type: str = None,
+        package_used_up_strategy: str = None,
+        period_end_time: str = None,
+        period_start_time: str = None,
+        post_paid_limit_fee: float = None,
+        total_duration: int = None,
+        used_duration: int = None,
+    ):
+        self.order_instance_id = order_instance_id
+        self.package_creation_time = package_creation_time
+        self.package_expired_time = package_expired_time
+        self.package_id = package_id
+        self.package_status = package_status
+        self.package_type = package_type
+        self.package_used_up_strategy = package_used_up_strategy
+        self.period_end_time = period_end_time
+        self.period_start_time = period_start_time
+        self.post_paid_limit_fee = post_paid_limit_fee
+        self.total_duration = total_duration
+        self.used_duration = used_duration
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.order_instance_id is not None:
+            result['OrderInstanceId'] = self.order_instance_id
+        if self.package_creation_time is not None:
+            result['PackageCreationTime'] = self.package_creation_time
+        if self.package_expired_time is not None:
+            result['PackageExpiredTime'] = self.package_expired_time
+        if self.package_id is not None:
+            result['PackageId'] = self.package_id
+        if self.package_status is not None:
+            result['PackageStatus'] = self.package_status
+        if self.package_type is not None:
+            result['PackageType'] = self.package_type
+        if self.package_used_up_strategy is not None:
+            result['PackageUsedUpStrategy'] = self.package_used_up_strategy
+        if self.period_end_time is not None:
+            result['PeriodEndTime'] = self.period_end_time
+        if self.period_start_time is not None:
+            result['PeriodStartTime'] = self.period_start_time
+        if self.post_paid_limit_fee is not None:
+            result['PostPaidLimitFee'] = self.post_paid_limit_fee
+        if self.total_duration is not None:
+            result['TotalDuration'] = self.total_duration
+        if self.used_duration is not None:
+            result['UsedDuration'] = self.used_duration
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('OrderInstanceId') is not None:
+            self.order_instance_id = m.get('OrderInstanceId')
+        if m.get('PackageCreationTime') is not None:
+            self.package_creation_time = m.get('PackageCreationTime')
+        if m.get('PackageExpiredTime') is not None:
+            self.package_expired_time = m.get('PackageExpiredTime')
+        if m.get('PackageId') is not None:
+            self.package_id = m.get('PackageId')
+        if m.get('PackageStatus') is not None:
+            self.package_status = m.get('PackageStatus')
+        if m.get('PackageType') is not None:
+            self.package_type = m.get('PackageType')
+        if m.get('PackageUsedUpStrategy') is not None:
+            self.package_used_up_strategy = m.get('PackageUsedUpStrategy')
+        if m.get('PeriodEndTime') is not None:
+            self.period_end_time = m.get('PeriodEndTime')
+        if m.get('PeriodStartTime') is not None:
+            self.period_start_time = m.get('PeriodStartTime')
+        if m.get('PostPaidLimitFee') is not None:
+            self.post_paid_limit_fee = m.get('PostPaidLimitFee')
+        if m.get('TotalDuration') is not None:
+            self.total_duration = m.get('TotalDuration')
+        if m.get('UsedDuration') is not None:
+            self.used_duration = m.get('UsedDuration')
+        return self
+
+
+class DescribeUserResourcesResponseBodyResourcesDesktopTimers(TeaModel):
+    def __init__(
+        self,
+        allow_client_setting: str = None,
+        cron_expression: str = None,
+        enforce: bool = None,
+        execution_time: str = None,
+        interval: int = None,
+        operation_type: str = None,
+        reset_type: str = None,
+        timer_type: str = None,
+    ):
+        self.allow_client_setting = allow_client_setting
+        self.cron_expression = cron_expression
+        self.enforce = enforce
+        self.execution_time = execution_time
+        self.interval = interval
+        self.operation_type = operation_type
+        self.reset_type = reset_type
+        self.timer_type = timer_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.allow_client_setting is not None:
+            result['AllowClientSetting'] = self.allow_client_setting
+        if self.cron_expression is not None:
+            result['CronExpression'] = self.cron_expression
+        if self.enforce is not None:
+            result['Enforce'] = self.enforce
+        if self.execution_time is not None:
+            result['ExecutionTime'] = self.execution_time
+        if self.interval is not None:
+            result['Interval'] = self.interval
+        if self.operation_type is not None:
+            result['OperationType'] = self.operation_type
+        if self.reset_type is not None:
+            result['ResetType'] = self.reset_type
+        if self.timer_type is not None:
+            result['TimerType'] = self.timer_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AllowClientSetting') is not None:
+            self.allow_client_setting = m.get('AllowClientSetting')
+        if m.get('CronExpression') is not None:
+            self.cron_expression = m.get('CronExpression')
+        if m.get('Enforce') is not None:
+            self.enforce = m.get('Enforce')
+        if m.get('ExecutionTime') is not None:
+            self.execution_time = m.get('ExecutionTime')
+        if m.get('Interval') is not None:
+            self.interval = m.get('Interval')
+        if m.get('OperationType') is not None:
+            self.operation_type = m.get('OperationType')
+        if m.get('ResetType') is not None:
+            self.reset_type = m.get('ResetType')
+        if m.get('TimerType') is not None:
+            self.timer_type = m.get('TimerType')
+        return self
+
+
+class DescribeUserResourcesResponseBodyResourcesFotaUpdate(TeaModel):
+    def __init__(
+        self,
+        channel: str = None,
+        current_app_version: str = None,
+        force: bool = None,
+        new_app_version: str = None,
+        new_dcd_version: str = None,
+        project: str = None,
+        release_note: str = None,
+        release_note_en: str = None,
+        release_note_jp: str = None,
+        size: str = None,
+    ):
+        self.channel = channel
+        self.current_app_version = current_app_version
+        self.force = force
+        self.new_app_version = new_app_version
+        self.new_dcd_version = new_dcd_version
+        self.project = project
+        self.release_note = release_note
+        self.release_note_en = release_note_en
+        self.release_note_jp = release_note_jp
+        self.size = size
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.channel is not None:
+            result['Channel'] = self.channel
+        if self.current_app_version is not None:
+            result['CurrentAppVersion'] = self.current_app_version
+        if self.force is not None:
+            result['Force'] = self.force
+        if self.new_app_version is not None:
+            result['NewAppVersion'] = self.new_app_version
+        if self.new_dcd_version is not None:
+            result['NewDcdVersion'] = self.new_dcd_version
+        if self.project is not None:
+            result['Project'] = self.project
+        if self.release_note is not None:
+            result['ReleaseNote'] = self.release_note
+        if self.release_note_en is not None:
+            result['ReleaseNoteEn'] = self.release_note_en
+        if self.release_note_jp is not None:
+            result['ReleaseNoteJp'] = self.release_note_jp
+        if self.size is not None:
+            result['Size'] = self.size
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Channel') is not None:
+            self.channel = m.get('Channel')
+        if m.get('CurrentAppVersion') is not None:
+            self.current_app_version = m.get('CurrentAppVersion')
+        if m.get('Force') is not None:
+            self.force = m.get('Force')
+        if m.get('NewAppVersion') is not None:
+            self.new_app_version = m.get('NewAppVersion')
+        if m.get('NewDcdVersion') is not None:
+            self.new_dcd_version = m.get('NewDcdVersion')
+        if m.get('Project') is not None:
+            self.project = m.get('Project')
+        if m.get('ReleaseNote') is not None:
+            self.release_note = m.get('ReleaseNote')
+        if m.get('ReleaseNoteEn') is not None:
+            self.release_note_en = m.get('ReleaseNoteEn')
+        if m.get('ReleaseNoteJp') is not None:
+            self.release_note_jp = m.get('ReleaseNoteJp')
+        if m.get('Size') is not None:
+            self.size = m.get('Size')
+        return self
+
+
+class DescribeUserResourcesResponseBodyResourcesSessions(TeaModel):
+    def __init__(
+        self,
+        resource_session_start_time: str = None,
+        user_id: str = None,
+        user_principal_name: str = None,
+    ):
+        self.resource_session_start_time = resource_session_start_time
+        self.user_id = user_id
+        self.user_principal_name = user_principal_name
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.resource_session_start_time is not None:
+            result['ResourceSessionStartTime'] = self.resource_session_start_time
+        if self.user_id is not None:
+            result['UserId'] = self.user_id
+        if self.user_principal_name is not None:
+            result['UserPrincipalName'] = self.user_principal_name
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ResourceSessionStartTime') is not None:
+            self.resource_session_start_time = m.get('ResourceSessionStartTime')
+        if m.get('UserId') is not None:
+            self.user_id = m.get('UserId')
+        if m.get('UserPrincipalName') is not None:
+            self.user_principal_name = m.get('UserPrincipalName')
+        return self
+
+
+class DescribeUserResourcesResponseBodyResources(TeaModel):
+    def __init__(
+        self,
+        access_type: str = None,
+        ali_uid: int = None,
+        app_id: str = None,
+        auth_mode: str = None,
+        category_id: int = None,
+        category_type: int = None,
+        cds_name: str = None,
+        center_resource_id: str = None,
+        charge_type: str = None,
+        clients: List[DescribeUserResourcesResponseBodyResourcesClients] = None,
+        connection_properties: str = None,
+        create_time: str = None,
+        desktop_duration_list: List[DescribeUserResourcesResponseBodyResourcesDesktopDurationList] = None,
+        desktop_timers: List[DescribeUserResourcesResponseBodyResourcesDesktopTimers] = None,
+        expired_time: str = None,
+        external_domain_id: str = None,
+        external_user_id: str = None,
+        fota_update: DescribeUserResourcesResponseBodyResourcesFotaUpdate = None,
+        global_status: bool = None,
+        hibernation_beta: bool = None,
+        icon: str = None,
+        last_start_time: str = None,
+        local_name: str = None,
+        management_statuses: List[str] = None,
+        office_site_id: str = None,
+        order_status: str = None,
+        os: str = None,
+        os_description: str = None,
+        os_type: str = None,
+        product_type: str = None,
+        protocol_type: str = None,
+        real_desktop_id: str = None,
+        region_id: str = None,
+        region_location: str = None,
+        resource_group_id: str = None,
+        resource_id: str = None,
+        resource_level: str = None,
+        resource_name: str = None,
+        resource_session_status: str = None,
+        resource_status: str = None,
+        resource_type: str = None,
+        session_type: str = None,
+        sessions: List[DescribeUserResourcesResponseBodyResourcesSessions] = None,
+        sub_pay_type: str = None,
+        support_hibernation: bool = None,
+        supported_actions: List[str] = None,
+        theme_color: str = None,
+        user_custom_name: str = None,
+        version: str = None,
+    ):
+        self.access_type = access_type
+        self.ali_uid = ali_uid
+        self.app_id = app_id
+        self.auth_mode = auth_mode
+        self.category_id = category_id
+        self.category_type = category_type
+        self.cds_name = cds_name
+        self.center_resource_id = center_resource_id
+        self.charge_type = charge_type
+        self.clients = clients
+        self.connection_properties = connection_properties
+        self.create_time = create_time
+        self.desktop_duration_list = desktop_duration_list
+        self.desktop_timers = desktop_timers
+        self.expired_time = expired_time
+        self.external_domain_id = external_domain_id
+        self.external_user_id = external_user_id
+        self.fota_update = fota_update
+        self.global_status = global_status
+        self.hibernation_beta = hibernation_beta
+        self.icon = icon
+        self.last_start_time = last_start_time
+        self.local_name = local_name
+        self.management_statuses = management_statuses
+        self.office_site_id = office_site_id
+        self.order_status = order_status
+        self.os = os
+        self.os_description = os_description
+        self.os_type = os_type
+        self.product_type = product_type
+        self.protocol_type = protocol_type
+        self.real_desktop_id = real_desktop_id
+        self.region_id = region_id
+        self.region_location = region_location
+        self.resource_group_id = resource_group_id
+        self.resource_id = resource_id
+        self.resource_level = resource_level
+        self.resource_name = resource_name
+        self.resource_session_status = resource_session_status
+        self.resource_status = resource_status
+        self.resource_type = resource_type
+        self.session_type = session_type
+        self.sessions = sessions
+        self.sub_pay_type = sub_pay_type
+        self.support_hibernation = support_hibernation
+        self.supported_actions = supported_actions
+        self.theme_color = theme_color
+        self.user_custom_name = user_custom_name
+        self.version = version
+
+    def validate(self):
+        if self.clients:
+            for k in self.clients:
+                if k:
+                    k.validate()
+        if self.desktop_duration_list:
+            for k in self.desktop_duration_list:
+                if k:
+                    k.validate()
+        if self.desktop_timers:
+            for k in self.desktop_timers:
+                if k:
+                    k.validate()
+        if self.fota_update:
+            self.fota_update.validate()
+        if self.sessions:
+            for k in self.sessions:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.access_type is not None:
+            result['AccessType'] = self.access_type
+        if self.ali_uid is not None:
+            result['AliUid'] = self.ali_uid
+        if self.app_id is not None:
+            result['AppId'] = self.app_id
+        if self.auth_mode is not None:
+            result['AuthMode'] = self.auth_mode
+        if self.category_id is not None:
+            result['CategoryId'] = self.category_id
+        if self.category_type is not None:
+            result['CategoryType'] = self.category_type
+        if self.cds_name is not None:
+            result['CdsName'] = self.cds_name
+        if self.center_resource_id is not None:
+            result['CenterResourceId'] = self.center_resource_id
+        if self.charge_type is not None:
+            result['ChargeType'] = self.charge_type
+        result['Clients'] = []
+        if self.clients is not None:
+            for k in self.clients:
+                result['Clients'].append(k.to_map() if k else None)
+        if self.connection_properties is not None:
+            result['ConnectionProperties'] = self.connection_properties
+        if self.create_time is not None:
+            result['CreateTime'] = self.create_time
+        result['DesktopDurationList'] = []
+        if self.desktop_duration_list is not None:
+            for k in self.desktop_duration_list:
+                result['DesktopDurationList'].append(k.to_map() if k else None)
+        result['DesktopTimers'] = []
+        if self.desktop_timers is not None:
+            for k in self.desktop_timers:
+                result['DesktopTimers'].append(k.to_map() if k else None)
+        if self.expired_time is not None:
+            result['ExpiredTime'] = self.expired_time
+        if self.external_domain_id is not None:
+            result['ExternalDomainId'] = self.external_domain_id
+        if self.external_user_id is not None:
+            result['ExternalUserId'] = self.external_user_id
+        if self.fota_update is not None:
+            result['FotaUpdate'] = self.fota_update.to_map()
+        if self.global_status is not None:
+            result['GlobalStatus'] = self.global_status
+        if self.hibernation_beta is not None:
+            result['HibernationBeta'] = self.hibernation_beta
+        if self.icon is not None:
+            result['Icon'] = self.icon
+        if self.last_start_time is not None:
+            result['LastStartTime'] = self.last_start_time
+        if self.local_name is not None:
+            result['LocalName'] = self.local_name
+        if self.management_statuses is not None:
+            result['ManagementStatuses'] = self.management_statuses
+        if self.office_site_id is not None:
+            result['OfficeSiteId'] = self.office_site_id
+        if self.order_status is not None:
+            result['OrderStatus'] = self.order_status
+        if self.os is not None:
+            result['Os'] = self.os
+        if self.os_description is not None:
+            result['OsDescription'] = self.os_description
+        if self.os_type is not None:
+            result['OsType'] = self.os_type
+        if self.product_type is not None:
+            result['ProductType'] = self.product_type
+        if self.protocol_type is not None:
+            result['ProtocolType'] = self.protocol_type
+        if self.real_desktop_id is not None:
+            result['RealDesktopId'] = self.real_desktop_id
+        if self.region_id is not None:
+            result['RegionId'] = self.region_id
+        if self.region_location is not None:
+            result['RegionLocation'] = self.region_location
+        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_level is not None:
+            result['ResourceLevel'] = self.resource_level
+        if self.resource_name is not None:
+            result['ResourceName'] = self.resource_name
+        if self.resource_session_status is not None:
+            result['ResourceSessionStatus'] = self.resource_session_status
+        if self.resource_status is not None:
+            result['ResourceStatus'] = self.resource_status
+        if self.resource_type is not None:
+            result['ResourceType'] = self.resource_type
+        if self.session_type is not None:
+            result['SessionType'] = self.session_type
+        result['Sessions'] = []
+        if self.sessions is not None:
+            for k in self.sessions:
+                result['Sessions'].append(k.to_map() if k else None)
+        if self.sub_pay_type is not None:
+            result['SubPayType'] = self.sub_pay_type
+        if self.support_hibernation is not None:
+            result['SupportHibernation'] = self.support_hibernation
+        if self.supported_actions is not None:
+            result['SupportedActions'] = self.supported_actions
+        if self.theme_color is not None:
+            result['ThemeColor'] = self.theme_color
+        if self.user_custom_name is not None:
+            result['UserCustomName'] = self.user_custom_name
+        if self.version is not None:
+            result['Version'] = self.version
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AccessType') is not None:
+            self.access_type = m.get('AccessType')
+        if m.get('AliUid') is not None:
+            self.ali_uid = m.get('AliUid')
+        if m.get('AppId') is not None:
+            self.app_id = m.get('AppId')
+        if m.get('AuthMode') is not None:
+            self.auth_mode = m.get('AuthMode')
+        if m.get('CategoryId') is not None:
+            self.category_id = m.get('CategoryId')
+        if m.get('CategoryType') is not None:
+            self.category_type = m.get('CategoryType')
+        if m.get('CdsName') is not None:
+            self.cds_name = m.get('CdsName')
+        if m.get('CenterResourceId') is not None:
+            self.center_resource_id = m.get('CenterResourceId')
+        if m.get('ChargeType') is not None:
+            self.charge_type = m.get('ChargeType')
+        self.clients = []
+        if m.get('Clients') is not None:
+            for k in m.get('Clients'):
+                temp_model = DescribeUserResourcesResponseBodyResourcesClients()
+                self.clients.append(temp_model.from_map(k))
+        if m.get('ConnectionProperties') is not None:
+            self.connection_properties = m.get('ConnectionProperties')
+        if m.get('CreateTime') is not None:
+            self.create_time = m.get('CreateTime')
+        self.desktop_duration_list = []
+        if m.get('DesktopDurationList') is not None:
+            for k in m.get('DesktopDurationList'):
+                temp_model = DescribeUserResourcesResponseBodyResourcesDesktopDurationList()
+                self.desktop_duration_list.append(temp_model.from_map(k))
+        self.desktop_timers = []
+        if m.get('DesktopTimers') is not None:
+            for k in m.get('DesktopTimers'):
+                temp_model = DescribeUserResourcesResponseBodyResourcesDesktopTimers()
+                self.desktop_timers.append(temp_model.from_map(k))
+        if m.get('ExpiredTime') is not None:
+            self.expired_time = m.get('ExpiredTime')
+        if m.get('ExternalDomainId') is not None:
+            self.external_domain_id = m.get('ExternalDomainId')
+        if m.get('ExternalUserId') is not None:
+            self.external_user_id = m.get('ExternalUserId')
+        if m.get('FotaUpdate') is not None:
+            temp_model = DescribeUserResourcesResponseBodyResourcesFotaUpdate()
+            self.fota_update = temp_model.from_map(m['FotaUpdate'])
+        if m.get('GlobalStatus') is not None:
+            self.global_status = m.get('GlobalStatus')
+        if m.get('HibernationBeta') is not None:
+            self.hibernation_beta = m.get('HibernationBeta')
+        if m.get('Icon') is not None:
+            self.icon = m.get('Icon')
+        if m.get('LastStartTime') is not None:
+            self.last_start_time = m.get('LastStartTime')
+        if m.get('LocalName') is not None:
+            self.local_name = m.get('LocalName')
+        if m.get('ManagementStatuses') is not None:
+            self.management_statuses = m.get('ManagementStatuses')
+        if m.get('OfficeSiteId') is not None:
+            self.office_site_id = m.get('OfficeSiteId')
+        if m.get('OrderStatus') is not None:
+            self.order_status = m.get('OrderStatus')
+        if m.get('Os') is not None:
+            self.os = m.get('Os')
+        if m.get('OsDescription') is not None:
+            self.os_description = m.get('OsDescription')
+        if m.get('OsType') is not None:
+            self.os_type = m.get('OsType')
+        if m.get('ProductType') is not None:
+            self.product_type = m.get('ProductType')
+        if m.get('ProtocolType') is not None:
+            self.protocol_type = m.get('ProtocolType')
+        if m.get('RealDesktopId') is not None:
+            self.real_desktop_id = m.get('RealDesktopId')
+        if m.get('RegionId') is not None:
+            self.region_id = m.get('RegionId')
+        if m.get('RegionLocation') is not None:
+            self.region_location = m.get('RegionLocation')
+        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('ResourceLevel') is not None:
+            self.resource_level = m.get('ResourceLevel')
+        if m.get('ResourceName') is not None:
+            self.resource_name = m.get('ResourceName')
+        if m.get('ResourceSessionStatus') is not None:
+            self.resource_session_status = m.get('ResourceSessionStatus')
+        if m.get('ResourceStatus') is not None:
+            self.resource_status = m.get('ResourceStatus')
+        if m.get('ResourceType') is not None:
+            self.resource_type = m.get('ResourceType')
+        if m.get('SessionType') is not None:
+            self.session_type = m.get('SessionType')
+        self.sessions = []
+        if m.get('Sessions') is not None:
+            for k in m.get('Sessions'):
+                temp_model = DescribeUserResourcesResponseBodyResourcesSessions()
+                self.sessions.append(temp_model.from_map(k))
+        if m.get('SubPayType') is not None:
+            self.sub_pay_type = m.get('SubPayType')
+        if m.get('SupportHibernation') is not None:
+            self.support_hibernation = m.get('SupportHibernation')
+        if m.get('SupportedActions') is not None:
+            self.supported_actions = m.get('SupportedActions')
+        if m.get('ThemeColor') is not None:
+            self.theme_color = m.get('ThemeColor')
+        if m.get('UserCustomName') is not None:
+            self.user_custom_name = m.get('UserCustomName')
+        if m.get('Version') is not None:
+            self.version = m.get('Version')
+        return self
+
+
+class DescribeUserResourcesResponseBody(TeaModel):
+    def __init__(
+        self,
+        next_token: str = None,
+        query_failed_resource_types: List[str] = None,
+        rank_version: int = None,
+        request_id: str = None,
+        resources: List[DescribeUserResourcesResponseBodyResources] = None,
+    ):
+        self.next_token = next_token
+        self.query_failed_resource_types = query_failed_resource_types
+        self.rank_version = rank_version
+        self.request_id = request_id
+        self.resources = resources
+
+    def validate(self):
+        if self.resources:
+            for k in self.resources:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.next_token is not None:
+            result['NextToken'] = self.next_token
+        if self.query_failed_resource_types is not None:
+            result['QueryFailedResourceTypes'] = self.query_failed_resource_types
+        if self.rank_version is not None:
+            result['RankVersion'] = self.rank_version
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        result['Resources'] = []
+        if self.resources is not None:
+            for k in self.resources:
+                result['Resources'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('NextToken') is not None:
+            self.next_token = m.get('NextToken')
+        if m.get('QueryFailedResourceTypes') is not None:
+            self.query_failed_resource_types = m.get('QueryFailedResourceTypes')
+        if m.get('RankVersion') is not None:
+            self.rank_version = m.get('RankVersion')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        self.resources = []
+        if m.get('Resources') is not None:
+            for k in m.get('Resources'):
+                temp_model = DescribeUserResourcesResponseBodyResources()
+                self.resources.append(temp_model.from_map(k))
+        return self
+
+
+class DescribeUserResourcesResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DescribeUserResourcesResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().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: dict = 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 = DescribeUserResourcesResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class EncryptPasswordRequest(TeaModel):
     def __init__(
         self,