alibabacloud-ehpcinstant20230701 3.0.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

alibabacloud_ehpcinstant20230701/models.py

@@ -324,6 +324,337 @@ class AddImageResponse(TeaModel):
         return self
 
 
+class CreateActionPlanRequestRegions(TeaModel):
+    def __init__(
+        self,
+        region_id: str = None,
+        security_group_id: List[str] = None,
+        security_group_ids: List[str] = None,
+        v_switch_ids: List[str] = None,
+    ):
+        self.region_id = region_id
+        self.security_group_id = security_group_id
+        self.security_group_ids = security_group_ids
+        self.v_switch_ids = v_switch_ids
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().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.security_group_id is not None:
+            result['SecurityGroupId'] = self.security_group_id
+        if self.security_group_ids is not None:
+            result['SecurityGroupIds'] = self.security_group_ids
+        if self.v_switch_ids is not None:
+            result['VSwitchIds'] = self.v_switch_ids
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('RegionId') is not None:
+            self.region_id = m.get('RegionId')
+        if m.get('SecurityGroupId') is not None:
+            self.security_group_id = m.get('SecurityGroupId')
+        if m.get('SecurityGroupIds') is not None:
+            self.security_group_ids = m.get('SecurityGroupIds')
+        if m.get('VSwitchIds') is not None:
+            self.v_switch_ids = m.get('VSwitchIds')
+        return self
+
+
+class CreateActionPlanRequestResources(TeaModel):
+    def __init__(
+        self,
+        cores: float = None,
+        memory: float = None,
+    ):
+        self.cores = cores
+        self.memory = memory
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.cores is not None:
+            result['Cores'] = self.cores
+        if self.memory is not None:
+            result['Memory'] = self.memory
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Cores') is not None:
+            self.cores = m.get('Cores')
+        if m.get('Memory') is not None:
+            self.memory = m.get('Memory')
+        return self
+
+
+class CreateActionPlanRequest(TeaModel):
+    def __init__(
+        self,
+        action_plan_name: str = None,
+        allocation_spec: str = None,
+        app_id: str = None,
+        desired_capacity: float = None,
+        level: str = None,
+        prolog_script: str = None,
+        regions: List[CreateActionPlanRequestRegions] = None,
+        resource_type: str = None,
+        resources: List[CreateActionPlanRequestResources] = None,
+        script: str = None,
+    ):
+        self.action_plan_name = action_plan_name
+        self.allocation_spec = allocation_spec
+        self.app_id = app_id
+        self.desired_capacity = desired_capacity
+        self.level = level
+        self.prolog_script = prolog_script
+        self.regions = regions
+        self.resource_type = resource_type
+        self.resources = resources
+        self.script = script
+
+    def validate(self):
+        if self.regions:
+            for k in self.regions:
+                if k:
+                    k.validate()
+        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.action_plan_name is not None:
+            result['ActionPlanName'] = self.action_plan_name
+        if self.allocation_spec is not None:
+            result['AllocationSpec'] = self.allocation_spec
+        if self.app_id is not None:
+            result['AppId'] = self.app_id
+        if self.desired_capacity is not None:
+            result['DesiredCapacity'] = self.desired_capacity
+        if self.level is not None:
+            result['Level'] = self.level
+        if self.prolog_script is not None:
+            result['PrologScript'] = self.prolog_script
+        result['Regions'] = []
+        if self.regions is not None:
+            for k in self.regions:
+                result['Regions'].append(k.to_map() if k else None)
+        if self.resource_type is not None:
+            result['ResourceType'] = self.resource_type
+        result['Resources'] = []
+        if self.resources is not None:
+            for k in self.resources:
+                result['Resources'].append(k.to_map() if k else None)
+        if self.script is not None:
+            result['Script'] = self.script
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ActionPlanName') is not None:
+            self.action_plan_name = m.get('ActionPlanName')
+        if m.get('AllocationSpec') is not None:
+            self.allocation_spec = m.get('AllocationSpec')
+        if m.get('AppId') is not None:
+            self.app_id = m.get('AppId')
+        if m.get('DesiredCapacity') is not None:
+            self.desired_capacity = m.get('DesiredCapacity')
+        if m.get('Level') is not None:
+            self.level = m.get('Level')
+        if m.get('PrologScript') is not None:
+            self.prolog_script = m.get('PrologScript')
+        self.regions = []
+        if m.get('Regions') is not None:
+            for k in m.get('Regions'):
+                temp_model = CreateActionPlanRequestRegions()
+                self.regions.append(temp_model.from_map(k))
+        if m.get('ResourceType') is not None:
+            self.resource_type = m.get('ResourceType')
+        self.resources = []
+        if m.get('Resources') is not None:
+            for k in m.get('Resources'):
+                temp_model = CreateActionPlanRequestResources()
+                self.resources.append(temp_model.from_map(k))
+        if m.get('Script') is not None:
+            self.script = m.get('Script')
+        return self
+
+
+class CreateActionPlanShrinkRequest(TeaModel):
+    def __init__(
+        self,
+        action_plan_name: str = None,
+        allocation_spec: str = None,
+        app_id: str = None,
+        desired_capacity: float = None,
+        level: str = None,
+        prolog_script: str = None,
+        regions_shrink: str = None,
+        resource_type: str = None,
+        resources_shrink: str = None,
+        script: str = None,
+    ):
+        self.action_plan_name = action_plan_name
+        self.allocation_spec = allocation_spec
+        self.app_id = app_id
+        self.desired_capacity = desired_capacity
+        self.level = level
+        self.prolog_script = prolog_script
+        self.regions_shrink = regions_shrink
+        self.resource_type = resource_type
+        self.resources_shrink = resources_shrink
+        self.script = script
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.action_plan_name is not None:
+            result['ActionPlanName'] = self.action_plan_name
+        if self.allocation_spec is not None:
+            result['AllocationSpec'] = self.allocation_spec
+        if self.app_id is not None:
+            result['AppId'] = self.app_id
+        if self.desired_capacity is not None:
+            result['DesiredCapacity'] = self.desired_capacity
+        if self.level is not None:
+            result['Level'] = self.level
+        if self.prolog_script is not None:
+            result['PrologScript'] = self.prolog_script
+        if self.regions_shrink is not None:
+            result['Regions'] = self.regions_shrink
+        if self.resource_type is not None:
+            result['ResourceType'] = self.resource_type
+        if self.resources_shrink is not None:
+            result['Resources'] = self.resources_shrink
+        if self.script is not None:
+            result['Script'] = self.script
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ActionPlanName') is not None:
+            self.action_plan_name = m.get('ActionPlanName')
+        if m.get('AllocationSpec') is not None:
+            self.allocation_spec = m.get('AllocationSpec')
+        if m.get('AppId') is not None:
+            self.app_id = m.get('AppId')
+        if m.get('DesiredCapacity') is not None:
+            self.desired_capacity = m.get('DesiredCapacity')
+        if m.get('Level') is not None:
+            self.level = m.get('Level')
+        if m.get('PrologScript') is not None:
+            self.prolog_script = m.get('PrologScript')
+        if m.get('Regions') is not None:
+            self.regions_shrink = m.get('Regions')
+        if m.get('ResourceType') is not None:
+            self.resource_type = m.get('ResourceType')
+        if m.get('Resources') is not None:
+            self.resources_shrink = m.get('Resources')
+        if m.get('Script') is not None:
+            self.script = m.get('Script')
+        return self
+
+
+class CreateActionPlanResponseBody(TeaModel):
+    def __init__(
+        self,
+        action_plan_id: str = None,
+        request_id: str = None,
+    ):
+        self.action_plan_id = action_plan_id
+        self.request_id = request_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.action_plan_id is not None:
+            result['ActionPlanId'] = self.action_plan_id
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ActionPlanId') is not None:
+            self.action_plan_id = m.get('ActionPlanId')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        return self
+
+
+class CreateActionPlanResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: CreateActionPlanResponseBody = 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 = CreateActionPlanResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class CreateJobRequestDependencyPolicyJobDependency(TeaModel):
     def __init__(
         self,
@@ -1619,14 +1950,12 @@ class CreatePoolResponse(TeaModel):
         return self
 
 
-class DeleteJobsRequestJobSpecTaskSpec(TeaModel):
+class DeleteActionPlanRequest(TeaModel):
     def __init__(
         self,
-        array_index: List[int] = None,
-        task_name: str = None,
+        action_plan_id: str = None,
     ):
-        self.array_index = array_index
-        self.task_name = task_name
+        self.action_plan_id = action_plan_id
 
     def validate(self):
         pass
@@ -1637,18 +1966,115 @@ class DeleteJobsRequestJobSpecTaskSpec(TeaModel):
             return _map
 
         result = dict()
-        if self.array_index is not None:
-            result['ArrayIndex'] = self.array_index
-        if self.task_name is not None:
-            result['TaskName'] = self.task_name
+        if self.action_plan_id is not None:
+            result['ActionPlanId'] = self.action_plan_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('ArrayIndex') is not None:
-            self.array_index = m.get('ArrayIndex')
-        if m.get('TaskName') is not None:
-            self.task_name = m.get('TaskName')
+        if m.get('ActionPlanId') is not None:
+            self.action_plan_id = m.get('ActionPlanId')
+        return self
+
+
+class DeleteActionPlanResponseBody(TeaModel):
+    def __init__(
+        self,
+        request_id: str = None,
+    ):
+        self.request_id = request_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().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: dict = None):
+        m = m or dict()
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        return self
+
+
+class DeleteActionPlanResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteActionPlanResponseBody = 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 = DeleteActionPlanResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class DeleteJobsRequestJobSpecTaskSpec(TeaModel):
+    def __init__(
+        self,
+        array_index: List[int] = None,
+        task_name: str = None,
+    ):
+        self.array_index = array_index
+        self.task_name = task_name
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.array_index is not None:
+            result['ArrayIndex'] = self.array_index
+        if self.task_name is not None:
+            result['TaskName'] = self.task_name
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ArrayIndex') is not None:
+            self.array_index = m.get('ArrayIndex')
+        if m.get('TaskName') is not None:
+            self.task_name = m.get('TaskName')
         return self
 
 
@@ -2307,21 +2733,12 @@ class DescribeJobMetricLastResponse(TeaModel):
         return self
 
 
-class GetAppVersionsRequest(TeaModel):
+class GetActionPlanRequest(TeaModel):
     def __init__(
         self,
-        app_name: str = None,
-        image_category: str = None,
-        image_type: str = None,
-        page_number: int = None,
-        page_size: int = None,
+        action_plan_id: str = None,
     ):
-        # This parameter is required.
-        self.app_name = app_name
-        self.image_category = image_category
-        self.image_type = image_type
-        self.page_number = page_number
-        self.page_size = page_size
+        self.action_plan_id = action_plan_id
 
     def validate(self):
         pass
@@ -2332,44 +2749,27 @@ class GetAppVersionsRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.app_name is not None:
-            result['AppName'] = self.app_name
-        if self.image_category is not None:
-            result['ImageCategory'] = self.image_category
-        if self.image_type is not None:
-            result['ImageType'] = self.image_type
-        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.action_plan_id is not None:
+            result['ActionPlanId'] = self.action_plan_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('AppName') is not None:
-            self.app_name = m.get('AppName')
-        if m.get('ImageCategory') is not None:
-            self.image_category = m.get('ImageCategory')
-        if m.get('ImageType') is not None:
-            self.image_type = m.get('ImageType')
-        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('ActionPlanId') is not None:
+            self.action_plan_id = m.get('ActionPlanId')
         return self
 
 
-class GetAppVersionsResponseBodyAppVersions(TeaModel):
+class GetActionPlanResponseBodyRegions(TeaModel):
     def __init__(
         self,
-        image_id: str = None,
-        name: str = None,
-        version: str = None,
+        region_id: str = None,
+        security_group_ids: List[str] = None,
+        v_switch_ids: List[str] = None,
     ):
-        # This parameter is required.
-        self.image_id = image_id
-        self.name = name
-        self.version = version
+        self.region_id = region_id
+        self.security_group_ids = security_group_ids
+        self.v_switch_ids = v_switch_ids
 
     def validate(self):
         pass
@@ -2380,47 +2780,36 @@ class GetAppVersionsResponseBodyAppVersions(TeaModel):
             return _map
 
         result = dict()
-        if self.image_id is not None:
-            result['ImageId'] = self.image_id
-        if self.name is not None:
-            result['Name'] = self.name
-        if self.version is not None:
-            result['Version'] = self.version
+        if self.region_id is not None:
+            result['RegionId'] = self.region_id
+        if self.security_group_ids is not None:
+            result['SecurityGroupIds'] = self.security_group_ids
+        if self.v_switch_ids is not None:
+            result['VSwitchIds'] = self.v_switch_ids
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('ImageId') is not None:
-            self.image_id = m.get('ImageId')
-        if m.get('Name') is not None:
-            self.name = m.get('Name')
-        if m.get('Version') is not None:
-            self.version = m.get('Version')
+        if m.get('RegionId') is not None:
+            self.region_id = m.get('RegionId')
+        if m.get('SecurityGroupIds') is not None:
+            self.security_group_ids = m.get('SecurityGroupIds')
+        if m.get('VSwitchIds') is not None:
+            self.v_switch_ids = m.get('VSwitchIds')
         return self
 
 
-class GetAppVersionsResponseBody(TeaModel):
+class GetActionPlanResponseBodyResources(TeaModel):
     def __init__(
         self,
-        app_versions: List[GetAppVersionsResponseBodyAppVersions] = None,
-        page_number: int = None,
-        page_size: int = None,
-        request_id: str = None,
-        success: bool = None,
-        total_count: int = None,
+        cores: float = None,
+        memory: float = None,
     ):
-        self.app_versions = app_versions
-        self.page_number = page_number
-        self.page_size = page_size
-        self.request_id = request_id
-        self.success = success
-        self.total_count = total_count
+        self.cores = cores
+        self.memory = memory
 
     def validate(self):
-        if self.app_versions:
-            for k in self.app_versions:
-                if k:
-                    k.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -2428,56 +2817,65 @@ class GetAppVersionsResponseBody(TeaModel):
             return _map
 
         result = dict()
-        result['AppVersions'] = []
-        if self.app_versions is not None:
-            for k in self.app_versions:
-                result['AppVersions'].append(k.to_map() if k else None)
-        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.success is not None:
-            result['Success'] = self.success
-        if self.total_count is not None:
-            result['TotalCount'] = self.total_count
+        if self.cores is not None:
+            result['Cores'] = self.cores
+        if self.memory is not None:
+            result['Memory'] = self.memory
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        self.app_versions = []
-        if m.get('AppVersions') is not None:
-            for k in m.get('AppVersions'):
-                temp_model = GetAppVersionsResponseBodyAppVersions()
-                self.app_versions.append(temp_model.from_map(k))
-        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('Success') is not None:
-            self.success = m.get('Success')
-        if m.get('TotalCount') is not None:
-            self.total_count = m.get('TotalCount')
+        if m.get('Cores') is not None:
+            self.cores = m.get('Cores')
+        if m.get('Memory') is not None:
+            self.memory = m.get('Memory')
         return self
 
 
-class GetAppVersionsResponse(TeaModel):
+class GetActionPlanResponseBody(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: GetAppVersionsResponseBody = None,
+        action_plan_id: str = None,
+        action_plan_name: str = None,
+        allocation_spec: str = None,
+        app_id: str = None,
+        create_time: str = None,
+        desired_capacity: float = None,
+        level: str = None,
+        prolog_script: str = None,
+        regions: List[GetActionPlanResponseBodyRegions] = None,
+        request_id: str = None,
+        resource_type: str = None,
+        resources: List[GetActionPlanResponseBodyResources] = None,
+        status: str = None,
+        total_capacity: float = None,
+        update_time: str = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
-        self.body = body
+        self.action_plan_id = action_plan_id
+        self.action_plan_name = action_plan_name
+        self.allocation_spec = allocation_spec
+        self.app_id = app_id
+        self.create_time = create_time
+        self.desired_capacity = desired_capacity
+        self.level = level
+        self.prolog_script = prolog_script
+        self.regions = regions
+        self.request_id = request_id
+        self.resource_type = resource_type
+        self.resources = resources
+        self.status = status
+        self.total_capacity = total_capacity
+        self.update_time = update_time
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        if self.regions:
+            for k in self.regions:
+                if k:
+                    k.validate()
+        if self.resources:
+            for k in self.resources:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -2485,41 +2883,97 @@ class GetAppVersionsResponse(TeaModel):
             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()
+        if self.action_plan_id is not None:
+            result['ActionPlanId'] = self.action_plan_id
+        if self.action_plan_name is not None:
+            result['ActionPlanName'] = self.action_plan_name
+        if self.allocation_spec is not None:
+            result['AllocationSpec'] = self.allocation_spec
+        if self.app_id is not None:
+            result['AppId'] = self.app_id
+        if self.create_time is not None:
+            result['CreateTime'] = self.create_time
+        if self.desired_capacity is not None:
+            result['DesiredCapacity'] = self.desired_capacity
+        if self.level is not None:
+            result['Level'] = self.level
+        if self.prolog_script is not None:
+            result['PrologScript'] = self.prolog_script
+        result['Regions'] = []
+        if self.regions is not None:
+            for k in self.regions:
+                result['Regions'].append(k.to_map() if k else None)
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        if self.resource_type is not None:
+            result['ResourceType'] = self.resource_type
+        result['Resources'] = []
+        if self.resources is not None:
+            for k in self.resources:
+                result['Resources'].append(k.to_map() if k else None)
+        if self.status is not None:
+            result['Status'] = self.status
+        if self.total_capacity is not None:
+            result['TotalCapacity'] = self.total_capacity
+        if self.update_time is not None:
+            result['UpdateTime'] = self.update_time
         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 = GetAppVersionsResponseBody()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('ActionPlanId') is not None:
+            self.action_plan_id = m.get('ActionPlanId')
+        if m.get('ActionPlanName') is not None:
+            self.action_plan_name = m.get('ActionPlanName')
+        if m.get('AllocationSpec') is not None:
+            self.allocation_spec = m.get('AllocationSpec')
+        if m.get('AppId') is not None:
+            self.app_id = m.get('AppId')
+        if m.get('CreateTime') is not None:
+            self.create_time = m.get('CreateTime')
+        if m.get('DesiredCapacity') is not None:
+            self.desired_capacity = m.get('DesiredCapacity')
+        if m.get('Level') is not None:
+            self.level = m.get('Level')
+        if m.get('PrologScript') is not None:
+            self.prolog_script = m.get('PrologScript')
+        self.regions = []
+        if m.get('Regions') is not None:
+            for k in m.get('Regions'):
+                temp_model = GetActionPlanResponseBodyRegions()
+                self.regions.append(temp_model.from_map(k))
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        if m.get('ResourceType') is not None:
+            self.resource_type = m.get('ResourceType')
+        self.resources = []
+        if m.get('Resources') is not None:
+            for k in m.get('Resources'):
+                temp_model = GetActionPlanResponseBodyResources()
+                self.resources.append(temp_model.from_map(k))
+        if m.get('Status') is not None:
+            self.status = m.get('Status')
+        if m.get('TotalCapacity') is not None:
+            self.total_capacity = m.get('TotalCapacity')
+        if m.get('UpdateTime') is not None:
+            self.update_time = m.get('UpdateTime')
         return self
 
 
-class GetImageRequest(TeaModel):
+class GetActionPlanResponse(TeaModel):
     def __init__(
         self,
-        additional_region_ids: List[str] = None,
-        image_category: str = None,
-        image_id: str = None,
-        image_type: str = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetActionPlanResponseBody = None,
     ):
-        self.additional_region_ids = additional_region_ids
-        self.image_category = image_category
-        self.image_id = image_id
-        self.image_type = image_type
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        pass
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -2527,41 +2981,41 @@ class GetImageRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.additional_region_ids is not None:
-            result['AdditionalRegionIds'] = self.additional_region_ids
-        if self.image_category is not None:
-            result['ImageCategory'] = self.image_category
-        if self.image_id is not None:
-            result['ImageId'] = self.image_id
-        if self.image_type is not None:
-            result['ImageType'] = self.image_type
+        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('AdditionalRegionIds') is not None:
-            self.additional_region_ids = m.get('AdditionalRegionIds')
-        if m.get('ImageCategory') is not None:
-            self.image_category = m.get('ImageCategory')
-        if m.get('ImageId') is not None:
-            self.image_id = m.get('ImageId')
-        if m.get('ImageType') is not None:
-            self.image_type = m.get('ImageType')
+        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 = GetActionPlanResponseBody()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetImageShrinkRequest(TeaModel):
+class GetAppVersionsRequest(TeaModel):
     def __init__(
         self,
-        additional_region_ids_shrink: str = None,
+        app_name: str = None,
         image_category: str = None,
-        image_id: str = None,
         image_type: str = None,
+        page_number: int = None,
+        page_size: int = None,
     ):
-        self.additional_region_ids_shrink = additional_region_ids_shrink
+        # This parameter is required.
+        self.app_name = app_name
         self.image_category = image_category
-        self.image_id = image_id
         self.image_type = image_type
+        self.page_number = page_number
+        self.page_size = page_size
 
     def validate(self):
         pass
@@ -2572,39 +3026,44 @@ class GetImageShrinkRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.additional_region_ids_shrink is not None:
-            result['AdditionalRegionIds'] = self.additional_region_ids_shrink
+        if self.app_name is not None:
+            result['AppName'] = self.app_name
         if self.image_category is not None:
             result['ImageCategory'] = self.image_category
-        if self.image_id is not None:
-            result['ImageId'] = self.image_id
         if self.image_type is not None:
             result['ImageType'] = self.image_type
+        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: dict = None):
         m = m or dict()
-        if m.get('AdditionalRegionIds') is not None:
-            self.additional_region_ids_shrink = m.get('AdditionalRegionIds')
+        if m.get('AppName') is not None:
+            self.app_name = m.get('AppName')
         if m.get('ImageCategory') is not None:
             self.image_category = m.get('ImageCategory')
-        if m.get('ImageId') is not None:
-            self.image_id = m.get('ImageId')
         if m.get('ImageType') is not None:
             self.image_type = m.get('ImageType')
+        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 GetImageResponseBodyImageAdditionalRegionsInfo(TeaModel):
+class GetAppVersionsResponseBodyAppVersions(TeaModel):
     def __init__(
         self,
         image_id: str = None,
-        region_id: str = None,
-        status: str = None,
+        name: str = None,
+        version: str = None,
     ):
+        # This parameter is required.
         self.image_id = image_id
-        self.region_id = region_id
-        self.status = status
+        self.name = name
+        self.version = version
 
     def validate(self):
         pass
@@ -2617,36 +3076,45 @@ class GetImageResponseBodyImageAdditionalRegionsInfo(TeaModel):
         result = dict()
         if self.image_id is not None:
             result['ImageId'] = self.image_id
-        if self.region_id is not None:
-            result['RegionId'] = self.region_id
-        if self.status is not None:
-            result['Status'] = self.status
+        if self.name is not None:
+            result['Name'] = self.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('ImageId') is not None:
             self.image_id = m.get('ImageId')
-        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')
+        if m.get('Name') is not None:
+            self.name = m.get('Name')
+        if m.get('Version') is not None:
+            self.version = m.get('Version')
         return self
 
 
-class GetImageResponseBodyImageContainerImageSpecRegistryCredential(TeaModel):
+class GetAppVersionsResponseBody(TeaModel):
     def __init__(
         self,
-        password: str = None,
-        server: str = None,
-        user_name: str = None,
+        app_versions: List[GetAppVersionsResponseBodyAppVersions] = None,
+        page_number: int = None,
+        page_size: int = None,
+        request_id: str = None,
+        success: bool = None,
+        total_count: int = None,
     ):
-        self.password = password
-        self.server = server
-        self.user_name = user_name
+        self.app_versions = app_versions
+        self.page_number = page_number
+        self.page_size = page_size
+        self.request_id = request_id
+        self.success = success
+        self.total_count = total_count
 
     def validate(self):
-        pass
+        if self.app_versions:
+            for k in self.app_versions:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -2654,49 +3122,56 @@ class GetImageResponseBodyImageContainerImageSpecRegistryCredential(TeaModel):
             return _map
 
         result = dict()
-        if self.password is not None:
-            result['Password'] = self.password
-        if self.server is not None:
-            result['Server'] = self.server
-        if self.user_name is not None:
-            result['UserName'] = self.user_name
+        result['AppVersions'] = []
+        if self.app_versions is not None:
+            for k in self.app_versions:
+                result['AppVersions'].append(k.to_map() if k else None)
+        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.success is not None:
+            result['Success'] = self.success
+        if self.total_count is not None:
+            result['TotalCount'] = self.total_count
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('Password') is not None:
-            self.password = m.get('Password')
-        if m.get('Server') is not None:
-            self.server = m.get('Server')
-        if m.get('UserName') is not None:
-            self.user_name = m.get('UserName')
+        self.app_versions = []
+        if m.get('AppVersions') is not None:
+            for k in m.get('AppVersions'):
+                temp_model = GetAppVersionsResponseBodyAppVersions()
+                self.app_versions.append(temp_model.from_map(k))
+        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('Success') is not None:
+            self.success = m.get('Success')
+        if m.get('TotalCount') is not None:
+            self.total_count = m.get('TotalCount')
         return self
 
 
-class GetImageResponseBodyImageContainerImageSpec(TeaModel):
+class GetAppVersionsResponse(TeaModel):
     def __init__(
         self,
-        architecture: str = None,
-        is_acrenterprise: bool = None,
-        is_acrregistry: bool = None,
-        os_tag: str = None,
-        platform: str = None,
-        registry_credential: GetImageResponseBodyImageContainerImageSpecRegistryCredential = None,
-        registry_cri_id: str = None,
-        registry_url: str = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetAppVersionsResponseBody = None,
     ):
-        self.architecture = architecture
-        self.is_acrenterprise = is_acrenterprise
-        self.is_acrregistry = is_acrregistry
-        self.os_tag = os_tag
-        self.platform = platform
-        self.registry_credential = registry_credential
-        self.registry_cri_id = registry_cri_id
-        self.registry_url = registry_url
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        if self.registry_credential:
-            self.registry_credential.validate()
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -2704,19 +3179,238 @@ class GetImageResponseBodyImageContainerImageSpec(TeaModel):
             return _map
 
         result = dict()
-        if self.architecture is not None:
-            result['Architecture'] = self.architecture
-        if self.is_acrenterprise is not None:
-            result['IsACREnterprise'] = self.is_acrenterprise
-        if self.is_acrregistry is not None:
-            result['IsACRRegistry'] = self.is_acrregistry
-        if self.os_tag is not None:
-            result['OsTag'] = self.os_tag
-        if self.platform is not None:
-            result['Platform'] = self.platform
-        if self.registry_credential is not None:
-            result['RegistryCredential'] = self.registry_credential.to_map()
-        if self.registry_cri_id is not None:
+        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 = GetAppVersionsResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetImageRequest(TeaModel):
+    def __init__(
+        self,
+        additional_region_ids: List[str] = None,
+        image_category: str = None,
+        image_id: str = None,
+        image_type: str = None,
+    ):
+        self.additional_region_ids = additional_region_ids
+        self.image_category = image_category
+        self.image_id = image_id
+        self.image_type = image_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.additional_region_ids is not None:
+            result['AdditionalRegionIds'] = self.additional_region_ids
+        if self.image_category is not None:
+            result['ImageCategory'] = self.image_category
+        if self.image_id is not None:
+            result['ImageId'] = self.image_id
+        if self.image_type is not None:
+            result['ImageType'] = self.image_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AdditionalRegionIds') is not None:
+            self.additional_region_ids = m.get('AdditionalRegionIds')
+        if m.get('ImageCategory') is not None:
+            self.image_category = m.get('ImageCategory')
+        if m.get('ImageId') is not None:
+            self.image_id = m.get('ImageId')
+        if m.get('ImageType') is not None:
+            self.image_type = m.get('ImageType')
+        return self
+
+
+class GetImageShrinkRequest(TeaModel):
+    def __init__(
+        self,
+        additional_region_ids_shrink: str = None,
+        image_category: str = None,
+        image_id: str = None,
+        image_type: str = None,
+    ):
+        self.additional_region_ids_shrink = additional_region_ids_shrink
+        self.image_category = image_category
+        self.image_id = image_id
+        self.image_type = image_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.additional_region_ids_shrink is not None:
+            result['AdditionalRegionIds'] = self.additional_region_ids_shrink
+        if self.image_category is not None:
+            result['ImageCategory'] = self.image_category
+        if self.image_id is not None:
+            result['ImageId'] = self.image_id
+        if self.image_type is not None:
+            result['ImageType'] = self.image_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AdditionalRegionIds') is not None:
+            self.additional_region_ids_shrink = m.get('AdditionalRegionIds')
+        if m.get('ImageCategory') is not None:
+            self.image_category = m.get('ImageCategory')
+        if m.get('ImageId') is not None:
+            self.image_id = m.get('ImageId')
+        if m.get('ImageType') is not None:
+            self.image_type = m.get('ImageType')
+        return self
+
+
+class GetImageResponseBodyImageAdditionalRegionsInfo(TeaModel):
+    def __init__(
+        self,
+        image_id: str = None,
+        region_id: str = None,
+        status: str = None,
+    ):
+        self.image_id = image_id
+        self.region_id = region_id
+        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.image_id is not None:
+            result['ImageId'] = self.image_id
+        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: dict = None):
+        m = m or dict()
+        if m.get('ImageId') is not None:
+            self.image_id = m.get('ImageId')
+        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 GetImageResponseBodyImageContainerImageSpecRegistryCredential(TeaModel):
+    def __init__(
+        self,
+        password: str = None,
+        server: str = None,
+        user_name: str = None,
+    ):
+        self.password = password
+        self.server = server
+        self.user_name = user_name
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.password is not None:
+            result['Password'] = self.password
+        if self.server is not None:
+            result['Server'] = self.server
+        if self.user_name is not None:
+            result['UserName'] = self.user_name
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Password') is not None:
+            self.password = m.get('Password')
+        if m.get('Server') is not None:
+            self.server = m.get('Server')
+        if m.get('UserName') is not None:
+            self.user_name = m.get('UserName')
+        return self
+
+
+class GetImageResponseBodyImageContainerImageSpec(TeaModel):
+    def __init__(
+        self,
+        architecture: str = None,
+        is_acrenterprise: bool = None,
+        is_acrregistry: bool = None,
+        os_tag: str = None,
+        platform: str = None,
+        registry_credential: GetImageResponseBodyImageContainerImageSpecRegistryCredential = None,
+        registry_cri_id: str = None,
+        registry_url: str = None,
+    ):
+        self.architecture = architecture
+        self.is_acrenterprise = is_acrenterprise
+        self.is_acrregistry = is_acrregistry
+        self.os_tag = os_tag
+        self.platform = platform
+        self.registry_credential = registry_credential
+        self.registry_cri_id = registry_cri_id
+        self.registry_url = registry_url
+
+    def validate(self):
+        if self.registry_credential:
+            self.registry_credential.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.architecture is not None:
+            result['Architecture'] = self.architecture
+        if self.is_acrenterprise is not None:
+            result['IsACREnterprise'] = self.is_acrenterprise
+        if self.is_acrregistry is not None:
+            result['IsACRRegistry'] = self.is_acrregistry
+        if self.os_tag is not None:
+            result['OsTag'] = self.os_tag
+        if self.platform is not None:
+            result['Platform'] = self.platform
+        if self.registry_credential is not None:
+            result['RegistryCredential'] = self.registry_credential.to_map()
+        if self.registry_cri_id is not None:
             result['RegistryCriId'] = self.registry_cri_id
         if self.registry_url is not None:
             result['RegistryUrl'] = self.registry_url
@@ -3376,22 +4070,476 @@ class GetJobResponseBodyJobInfoTasksExecutorStatus(TeaModel):
             self.start_time = m.get('StartTime')
         if m.get('Status') is not None:
             self.status = m.get('Status')
-        if m.get('StatusReason') is not None:
-            self.status_reason = m.get('StatusReason')
+        if m.get('StatusReason') is not None:
+            self.status_reason = m.get('StatusReason')
+        return self
+
+
+class GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks(TeaModel):
+    def __init__(
+        self,
+        size: int = None,
+        type: str = None,
+    ):
+        self.size = size
+        self.type = type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.size is not None:
+            result['Size'] = self.size
+        if self.type is not None:
+            result['Type'] = self.type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Size') is not None:
+            self.size = m.get('Size')
+        if m.get('Type') is not None:
+            self.type = m.get('Type')
+        return self
+
+
+class GetJobResponseBodyJobInfoTasksTaskSpecResource(TeaModel):
+    def __init__(
+        self,
+        cores: float = None,
+        disks: List[GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks] = None,
+        instance_types: List[str] = None,
+        memory: int = None,
+    ):
+        self.cores = cores
+        self.disks = disks
+        self.instance_types = instance_types
+        self.memory = memory
+
+    def validate(self):
+        if self.disks:
+            for k in self.disks:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.cores is not None:
+            result['Cores'] = self.cores
+        result['Disks'] = []
+        if self.disks is not None:
+            for k in self.disks:
+                result['Disks'].append(k.to_map() if k else None)
+        if self.instance_types is not None:
+            result['InstanceTypes'] = self.instance_types
+        if self.memory is not None:
+            result['Memory'] = self.memory
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Cores') is not None:
+            self.cores = m.get('Cores')
+        self.disks = []
+        if m.get('Disks') is not None:
+            for k in m.get('Disks'):
+                temp_model = GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks()
+                self.disks.append(temp_model.from_map(k))
+        if m.get('InstanceTypes') is not None:
+            self.instance_types = m.get('InstanceTypes')
+        if m.get('Memory') is not None:
+            self.memory = m.get('Memory')
+        return self
+
+
+class GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicyExitCodeActions(TeaModel):
+    def __init__(
+        self,
+        action: str = None,
+        exit_code: int = None,
+    ):
+        self.action = action
+        self.exit_code = exit_code
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.action is not None:
+            result['Action'] = self.action
+        if self.exit_code is not None:
+            result['ExitCode'] = self.exit_code
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Action') is not None:
+            self.action = m.get('Action')
+        if m.get('ExitCode') is not None:
+            self.exit_code = m.get('ExitCode')
+        return self
+
+
+class GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicy(TeaModel):
+    def __init__(
+        self,
+        exit_code_actions: List[GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicyExitCodeActions] = None,
+        retry_count: int = None,
+    ):
+        self.exit_code_actions = exit_code_actions
+        self.retry_count = retry_count
+
+    def validate(self):
+        if self.exit_code_actions:
+            for k in self.exit_code_actions:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        result['ExitCodeActions'] = []
+        if self.exit_code_actions is not None:
+            for k in self.exit_code_actions:
+                result['ExitCodeActions'].append(k.to_map() if k else None)
+        if self.retry_count is not None:
+            result['RetryCount'] = self.retry_count
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        self.exit_code_actions = []
+        if m.get('ExitCodeActions') is not None:
+            for k in m.get('ExitCodeActions'):
+                temp_model = GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicyExitCodeActions()
+                self.exit_code_actions.append(temp_model.from_map(k))
+        if m.get('RetryCount') is not None:
+            self.retry_count = m.get('RetryCount')
+        return self
+
+
+class GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutorVM(TeaModel):
+    def __init__(
+        self,
+        image: str = None,
+        prolog_script: str = None,
+        script: str = None,
+    ):
+        self.image = image
+        self.prolog_script = prolog_script
+        self.script = script
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.image is not None:
+            result['Image'] = self.image
+        if self.prolog_script is not None:
+            result['PrologScript'] = self.prolog_script
+        if self.script is not None:
+            result['Script'] = self.script
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Image') is not None:
+            self.image = m.get('Image')
+        if m.get('PrologScript') is not None:
+            self.prolog_script = m.get('PrologScript')
+        if m.get('Script') is not None:
+            self.script = m.get('Script')
+        return self
+
+
+class GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutor(TeaModel):
+    def __init__(
+        self,
+        vm: GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutorVM = None,
+    ):
+        self.vm = vm
+
+    def validate(self):
+        if self.vm:
+            self.vm.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.vm is not None:
+            result['VM'] = self.vm.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('VM') is not None:
+            temp_model = GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutorVM()
+            self.vm = temp_model.from_map(m['VM'])
+        return self
+
+
+class GetJobResponseBodyJobInfoTasksTaskSpec(TeaModel):
+    def __init__(
+        self,
+        resource: GetJobResponseBodyJobInfoTasksTaskSpecResource = None,
+        retry_policy: GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicy = None,
+        task_executor: List[GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutor] = None,
+    ):
+        self.resource = resource
+        self.retry_policy = retry_policy
+        self.task_executor = task_executor
+
+    def validate(self):
+        if self.resource:
+            self.resource.validate()
+        if self.retry_policy:
+            self.retry_policy.validate()
+        if self.task_executor:
+            for k in self.task_executor:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.resource is not None:
+            result['Resource'] = self.resource.to_map()
+        if self.retry_policy is not None:
+            result['RetryPolicy'] = self.retry_policy.to_map()
+        result['TaskExecutor'] = []
+        if self.task_executor is not None:
+            for k in self.task_executor:
+                result['TaskExecutor'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('Resource') is not None:
+            temp_model = GetJobResponseBodyJobInfoTasksTaskSpecResource()
+            self.resource = temp_model.from_map(m['Resource'])
+        if m.get('RetryPolicy') is not None:
+            temp_model = GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicy()
+            self.retry_policy = temp_model.from_map(m['RetryPolicy'])
+        self.task_executor = []
+        if m.get('TaskExecutor') is not None:
+            for k in m.get('TaskExecutor'):
+                temp_model = GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutor()
+                self.task_executor.append(temp_model.from_map(k))
+        return self
+
+
+class GetJobResponseBodyJobInfoTasks(TeaModel):
+    def __init__(
+        self,
+        executor_policy: GetJobResponseBodyJobInfoTasksExecutorPolicy = None,
+        executor_status: List[GetJobResponseBodyJobInfoTasksExecutorStatus] = None,
+        task_name: str = None,
+        task_spec: GetJobResponseBodyJobInfoTasksTaskSpec = None,
+        task_sustainable: bool = None,
+    ):
+        self.executor_policy = executor_policy
+        self.executor_status = executor_status
+        self.task_name = task_name
+        self.task_spec = task_spec
+        self.task_sustainable = task_sustainable
+
+    def validate(self):
+        if self.executor_policy:
+            self.executor_policy.validate()
+        if self.executor_status:
+            for k in self.executor_status:
+                if k:
+                    k.validate()
+        if self.task_spec:
+            self.task_spec.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.executor_policy is not None:
+            result['ExecutorPolicy'] = self.executor_policy.to_map()
+        result['ExecutorStatus'] = []
+        if self.executor_status is not None:
+            for k in self.executor_status:
+                result['ExecutorStatus'].append(k.to_map() if k else None)
+        if self.task_name is not None:
+            result['TaskName'] = self.task_name
+        if self.task_spec is not None:
+            result['TaskSpec'] = self.task_spec.to_map()
+        if self.task_sustainable is not None:
+            result['TaskSustainable'] = self.task_sustainable
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ExecutorPolicy') is not None:
+            temp_model = GetJobResponseBodyJobInfoTasksExecutorPolicy()
+            self.executor_policy = temp_model.from_map(m['ExecutorPolicy'])
+        self.executor_status = []
+        if m.get('ExecutorStatus') is not None:
+            for k in m.get('ExecutorStatus'):
+                temp_model = GetJobResponseBodyJobInfoTasksExecutorStatus()
+                self.executor_status.append(temp_model.from_map(k))
+        if m.get('TaskName') is not None:
+            self.task_name = m.get('TaskName')
+        if m.get('TaskSpec') is not None:
+            temp_model = GetJobResponseBodyJobInfoTasksTaskSpec()
+            self.task_spec = temp_model.from_map(m['TaskSpec'])
+        if m.get('TaskSustainable') is not None:
+            self.task_sustainable = m.get('TaskSustainable')
+        return self
+
+
+class GetJobResponseBodyJobInfo(TeaModel):
+    def __init__(
+        self,
+        app_extra_info: str = None,
+        create_time: str = None,
+        dependency_policy: GetJobResponseBodyJobInfoDependencyPolicy = None,
+        deployment_policy: GetJobResponseBodyJobInfoDeploymentPolicy = None,
+        end_time: str = None,
+        job_description: str = None,
+        job_id: str = None,
+        job_name: str = None,
+        job_scheduler: str = None,
+        start_time: str = None,
+        status: str = None,
+        tasks: List[GetJobResponseBodyJobInfoTasks] = None,
+    ):
+        self.app_extra_info = app_extra_info
+        self.create_time = create_time
+        self.dependency_policy = dependency_policy
+        self.deployment_policy = deployment_policy
+        self.end_time = end_time
+        self.job_description = job_description
+        self.job_id = job_id
+        self.job_name = job_name
+        self.job_scheduler = job_scheduler
+        self.start_time = start_time
+        self.status = status
+        self.tasks = tasks
+
+    def validate(self):
+        if self.dependency_policy:
+            self.dependency_policy.validate()
+        if self.deployment_policy:
+            self.deployment_policy.validate()
+        if self.tasks:
+            for k in self.tasks:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.app_extra_info is not None:
+            result['AppExtraInfo'] = self.app_extra_info
+        if self.create_time is not None:
+            result['CreateTime'] = self.create_time
+        if self.dependency_policy is not None:
+            result['DependencyPolicy'] = self.dependency_policy.to_map()
+        if self.deployment_policy is not None:
+            result['DeploymentPolicy'] = self.deployment_policy.to_map()
+        if self.end_time is not None:
+            result['EndTime'] = self.end_time
+        if self.job_description is not None:
+            result['JobDescription'] = self.job_description
+        if self.job_id is not None:
+            result['JobId'] = self.job_id
+        if self.job_name is not None:
+            result['JobName'] = self.job_name
+        if self.job_scheduler is not None:
+            result['JobScheduler'] = self.job_scheduler
+        if self.start_time is not None:
+            result['StartTime'] = self.start_time
+        if self.status is not None:
+            result['Status'] = self.status
+        result['Tasks'] = []
+        if self.tasks is not None:
+            for k in self.tasks:
+                result['Tasks'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AppExtraInfo') is not None:
+            self.app_extra_info = m.get('AppExtraInfo')
+        if m.get('CreateTime') is not None:
+            self.create_time = m.get('CreateTime')
+        if m.get('DependencyPolicy') is not None:
+            temp_model = GetJobResponseBodyJobInfoDependencyPolicy()
+            self.dependency_policy = temp_model.from_map(m['DependencyPolicy'])
+        if m.get('DeploymentPolicy') is not None:
+            temp_model = GetJobResponseBodyJobInfoDeploymentPolicy()
+            self.deployment_policy = temp_model.from_map(m['DeploymentPolicy'])
+        if m.get('EndTime') is not None:
+            self.end_time = m.get('EndTime')
+        if m.get('JobDescription') is not None:
+            self.job_description = m.get('JobDescription')
+        if m.get('JobId') is not None:
+            self.job_id = m.get('JobId')
+        if m.get('JobName') is not None:
+            self.job_name = m.get('JobName')
+        if m.get('JobScheduler') is not None:
+            self.job_scheduler = m.get('JobScheduler')
+        if m.get('StartTime') is not None:
+            self.start_time = m.get('StartTime')
+        if m.get('Status') is not None:
+            self.status = m.get('Status')
+        self.tasks = []
+        if m.get('Tasks') is not None:
+            for k in m.get('Tasks'):
+                temp_model = GetJobResponseBodyJobInfoTasks()
+                self.tasks.append(temp_model.from_map(k))
         return self
 
 
-class GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks(TeaModel):
+class GetJobResponseBody(TeaModel):
     def __init__(
         self,
-        size: int = None,
-        type: str = None,
+        job_info: GetJobResponseBodyJobInfo = None,
+        request_id: str = None,
     ):
-        self.size = size
-        self.type = type
+        self.job_info = job_info
+        self.request_id = request_id
 
     def validate(self):
-        pass
+        if self.job_info:
+            self.job_info.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -3399,39 +4547,36 @@ class GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks(TeaModel):
             return _map
 
         result = dict()
-        if self.size is not None:
-            result['Size'] = self.size
-        if self.type is not None:
-            result['Type'] = self.type
+        if self.job_info is not None:
+            result['JobInfo'] = self.job_info.to_map()
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('Size') is not None:
-            self.size = m.get('Size')
-        if m.get('Type') is not None:
-            self.type = m.get('Type')
+        if m.get('JobInfo') is not None:
+            temp_model = GetJobResponseBodyJobInfo()
+            self.job_info = temp_model.from_map(m['JobInfo'])
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
         return self
 
 
-class GetJobResponseBodyJobInfoTasksTaskSpecResource(TeaModel):
+class GetJobResponse(TeaModel):
     def __init__(
         self,
-        cores: float = None,
-        disks: List[GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks] = None,
-        instance_types: List[str] = None,
-        memory: int = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetJobResponseBody = None,
     ):
-        self.cores = cores
-        self.disks = disks
-        self.instance_types = instance_types
-        self.memory = memory
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        if self.disks:
-            for k in self.disks:
-                if k:
-                    k.validate()
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -3439,42 +4584,33 @@ class GetJobResponseBodyJobInfoTasksTaskSpecResource(TeaModel):
             return _map
 
         result = dict()
-        if self.cores is not None:
-            result['Cores'] = self.cores
-        result['Disks'] = []
-        if self.disks is not None:
-            for k in self.disks:
-                result['Disks'].append(k.to_map() if k else None)
-        if self.instance_types is not None:
-            result['InstanceTypes'] = self.instance_types
-        if self.memory is not None:
-            result['Memory'] = self.memory
+        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('Cores') is not None:
-            self.cores = m.get('Cores')
-        self.disks = []
-        if m.get('Disks') is not None:
-            for k in m.get('Disks'):
-                temp_model = GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks()
-                self.disks.append(temp_model.from_map(k))
-        if m.get('InstanceTypes') is not None:
-            self.instance_types = m.get('InstanceTypes')
-        if m.get('Memory') is not None:
-            self.memory = m.get('Memory')
+        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 = GetJobResponseBody()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicyExitCodeActions(TeaModel):
+class GetPoolRequest(TeaModel):
     def __init__(
         self,
-        action: str = None,
-        exit_code: int = None,
+        pool_name: str = None,
     ):
-        self.action = action
-        self.exit_code = exit_code
+        # This parameter is required.
+        self.pool_name = pool_name
 
     def validate(self):
         pass
@@ -3485,35 +4621,42 @@ class GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicyExitCodeActions(TeaModel)
             return _map
 
         result = dict()
-        if self.action is not None:
-            result['Action'] = self.action
-        if self.exit_code is not None:
-            result['ExitCode'] = self.exit_code
+        if self.pool_name is not None:
+            result['PoolName'] = self.pool_name
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('Action') is not None:
-            self.action = m.get('Action')
-        if m.get('ExitCode') is not None:
-            self.exit_code = m.get('ExitCode')
+        if m.get('PoolName') is not None:
+            self.pool_name = m.get('PoolName')
         return self
 
 
-class GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicy(TeaModel):
+class GetPoolResponseBodyPoolInfo(TeaModel):
     def __init__(
         self,
-        exit_code_actions: List[GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicyExitCodeActions] = None,
-        retry_count: int = None,
+        create_time: str = None,
+        exector_usage: int = None,
+        is_default: bool = None,
+        max_exector_num: int = None,
+        pool_name: str = None,
+        priority: int = None,
+        reason: str = None,
+        status: str = None,
+        update_time: str = None,
     ):
-        self.exit_code_actions = exit_code_actions
-        self.retry_count = retry_count
+        self.create_time = create_time
+        self.exector_usage = exector_usage
+        self.is_default = is_default
+        self.max_exector_num = max_exector_num
+        self.pool_name = pool_name
+        self.priority = priority
+        self.reason = reason
+        self.status = status
+        self.update_time = update_time
 
     def validate(self):
-        if self.exit_code_actions:
-            for k in self.exit_code_actions:
-                if k:
-                    k.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -3521,39 +4664,62 @@ class GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicy(TeaModel):
             return _map
 
         result = dict()
-        result['ExitCodeActions'] = []
-        if self.exit_code_actions is not None:
-            for k in self.exit_code_actions:
-                result['ExitCodeActions'].append(k.to_map() if k else None)
-        if self.retry_count is not None:
-            result['RetryCount'] = self.retry_count
+        if self.create_time is not None:
+            result['CreateTime'] = self.create_time
+        if self.exector_usage is not None:
+            result['ExectorUsage'] = self.exector_usage
+        if self.is_default is not None:
+            result['IsDefault'] = self.is_default
+        if self.max_exector_num is not None:
+            result['MaxExectorNum'] = self.max_exector_num
+        if self.pool_name is not None:
+            result['PoolName'] = self.pool_name
+        if self.priority is not None:
+            result['Priority'] = self.priority
+        if self.reason is not None:
+            result['Reason'] = self.reason
+        if self.status is not None:
+            result['Status'] = self.status
+        if self.update_time is not None:
+            result['UpdateTime'] = self.update_time
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        self.exit_code_actions = []
-        if m.get('ExitCodeActions') is not None:
-            for k in m.get('ExitCodeActions'):
-                temp_model = GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicyExitCodeActions()
-                self.exit_code_actions.append(temp_model.from_map(k))
-        if m.get('RetryCount') is not None:
-            self.retry_count = m.get('RetryCount')
+        if m.get('CreateTime') is not None:
+            self.create_time = m.get('CreateTime')
+        if m.get('ExectorUsage') is not None:
+            self.exector_usage = m.get('ExectorUsage')
+        if m.get('IsDefault') is not None:
+            self.is_default = m.get('IsDefault')
+        if m.get('MaxExectorNum') is not None:
+            self.max_exector_num = m.get('MaxExectorNum')
+        if m.get('PoolName') is not None:
+            self.pool_name = m.get('PoolName')
+        if m.get('Priority') is not None:
+            self.priority = m.get('Priority')
+        if m.get('Reason') is not None:
+            self.reason = m.get('Reason')
+        if m.get('Status') is not None:
+            self.status = m.get('Status')
+        if m.get('UpdateTime') is not None:
+            self.update_time = m.get('UpdateTime')
         return self
 
 
-class GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutorVM(TeaModel):
+class GetPoolResponseBody(TeaModel):
     def __init__(
         self,
-        image: str = None,
-        prolog_script: str = None,
-        script: str = None,
+        pool_info: GetPoolResponseBodyPoolInfo = None,
+        request_id: str = None,
     ):
-        self.image = image
-        self.prolog_script = prolog_script
-        self.script = script
+        self.pool_info = pool_info
+        # Id of the request
+        self.request_id = request_id
 
     def validate(self):
-        pass
+        if self.pool_info:
+            self.pool_info.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -3561,35 +4727,36 @@ class GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutorVM(TeaModel):
             return _map
 
         result = dict()
-        if self.image is not None:
-            result['Image'] = self.image
-        if self.prolog_script is not None:
-            result['PrologScript'] = self.prolog_script
-        if self.script is not None:
-            result['Script'] = self.script
+        if self.pool_info is not None:
+            result['PoolInfo'] = self.pool_info.to_map()
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('Image') is not None:
-            self.image = m.get('Image')
-        if m.get('PrologScript') is not None:
-            self.prolog_script = m.get('PrologScript')
-        if m.get('Script') is not None:
-            self.script = m.get('Script')
+        if m.get('PoolInfo') is not None:
+            temp_model = GetPoolResponseBodyPoolInfo()
+            self.pool_info = temp_model.from_map(m['PoolInfo'])
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
         return self
 
 
-class GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutor(TeaModel):
+class GetPoolResponse(TeaModel):
     def __init__(
         self,
-        vm: GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutorVM = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetPoolResponseBody = None,
     ):
-        self.vm = vm
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        if self.vm:
-            self.vm.validate()
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -3597,38 +4764,39 @@ class GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutor(TeaModel):
             return _map
 
         result = dict()
-        if self.vm is not None:
-            result['VM'] = self.vm.to_map()
+        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('VM') is not None:
-            temp_model = GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutorVM()
-            self.vm = temp_model.from_map(m['VM'])
+        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 = GetPoolResponseBody()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetJobResponseBodyJobInfoTasksTaskSpec(TeaModel):
+class ListActionPlanActivitiesRequest(TeaModel):
     def __init__(
         self,
-        resource: GetJobResponseBodyJobInfoTasksTaskSpecResource = None,
-        retry_policy: GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicy = None,
-        task_executor: List[GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutor] = None,
+        action_plan_id: str = None,
+        max_results: int = None,
+        next_token: str = None,
     ):
-        self.resource = resource
-        self.retry_policy = retry_policy
-        self.task_executor = task_executor
+        self.action_plan_id = action_plan_id
+        self.max_results = max_results
+        self.next_token = next_token
 
     def validate(self):
-        if self.resource:
-            self.resource.validate()
-        if self.retry_policy:
-            self.retry_policy.validate()
-        if self.task_executor:
-            for k in self.task_executor:
-                if k:
-                    k.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -3636,56 +4804,38 @@ class GetJobResponseBodyJobInfoTasksTaskSpec(TeaModel):
             return _map
 
         result = dict()
-        if self.resource is not None:
-            result['Resource'] = self.resource.to_map()
-        if self.retry_policy is not None:
-            result['RetryPolicy'] = self.retry_policy.to_map()
-        result['TaskExecutor'] = []
-        if self.task_executor is not None:
-            for k in self.task_executor:
-                result['TaskExecutor'].append(k.to_map() if k else None)
+        if self.action_plan_id is not None:
+            result['ActionPlanId'] = self.action_plan_id
+        if self.max_results is not None:
+            result['MaxResults'] = self.max_results
+        if self.next_token is not None:
+            result['NextToken'] = self.next_token
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('Resource') is not None:
-            temp_model = GetJobResponseBodyJobInfoTasksTaskSpecResource()
-            self.resource = temp_model.from_map(m['Resource'])
-        if m.get('RetryPolicy') is not None:
-            temp_model = GetJobResponseBodyJobInfoTasksTaskSpecRetryPolicy()
-            self.retry_policy = temp_model.from_map(m['RetryPolicy'])
-        self.task_executor = []
-        if m.get('TaskExecutor') is not None:
-            for k in m.get('TaskExecutor'):
-                temp_model = GetJobResponseBodyJobInfoTasksTaskSpecTaskExecutor()
-                self.task_executor.append(temp_model.from_map(k))
+        if m.get('ActionPlanId') is not None:
+            self.action_plan_id = m.get('ActionPlanId')
+        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')
         return self
 
 
-class GetJobResponseBodyJobInfoTasks(TeaModel):
+class ListActionPlanActivitiesResponseBodyActionPlanActivitiesJobs(TeaModel):
     def __init__(
         self,
-        executor_policy: GetJobResponseBodyJobInfoTasksExecutorPolicy = None,
-        executor_status: List[GetJobResponseBodyJobInfoTasksExecutorStatus] = None,
-        task_name: str = None,
-        task_spec: GetJobResponseBodyJobInfoTasksTaskSpec = None,
-        task_sustainable: bool = None,
+        job_id: str = None,
+        job_operation_type: str = None,
+        region_id: str = None,
     ):
-        self.executor_policy = executor_policy
-        self.executor_status = executor_status
-        self.task_name = task_name
-        self.task_spec = task_spec
-        self.task_sustainable = task_sustainable
+        self.job_id = job_id
+        self.job_operation_type = job_operation_type
+        self.region_id = region_id
 
     def validate(self):
-        if self.executor_policy:
-            self.executor_policy.validate()
-        if self.executor_status:
-            for k in self.executor_status:
-                if k:
-                    k.validate()
-        if self.task_spec:
-            self.task_spec.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -3693,76 +4843,47 @@ class GetJobResponseBodyJobInfoTasks(TeaModel):
             return _map
 
         result = dict()
-        if self.executor_policy is not None:
-            result['ExecutorPolicy'] = self.executor_policy.to_map()
-        result['ExecutorStatus'] = []
-        if self.executor_status is not None:
-            for k in self.executor_status:
-                result['ExecutorStatus'].append(k.to_map() if k else None)
-        if self.task_name is not None:
-            result['TaskName'] = self.task_name
-        if self.task_spec is not None:
-            result['TaskSpec'] = self.task_spec.to_map()
-        if self.task_sustainable is not None:
-            result['TaskSustainable'] = self.task_sustainable
+        if self.job_id is not None:
+            result['JobId'] = self.job_id
+        if self.job_operation_type is not None:
+            result['JobOperationType'] = self.job_operation_type
+        if self.region_id is not None:
+            result['RegionId'] = self.region_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('ExecutorPolicy') is not None:
-            temp_model = GetJobResponseBodyJobInfoTasksExecutorPolicy()
-            self.executor_policy = temp_model.from_map(m['ExecutorPolicy'])
-        self.executor_status = []
-        if m.get('ExecutorStatus') is not None:
-            for k in m.get('ExecutorStatus'):
-                temp_model = GetJobResponseBodyJobInfoTasksExecutorStatus()
-                self.executor_status.append(temp_model.from_map(k))
-        if m.get('TaskName') is not None:
-            self.task_name = m.get('TaskName')
-        if m.get('TaskSpec') is not None:
-            temp_model = GetJobResponseBodyJobInfoTasksTaskSpec()
-            self.task_spec = temp_model.from_map(m['TaskSpec'])
-        if m.get('TaskSustainable') is not None:
-            self.task_sustainable = m.get('TaskSustainable')
+        if m.get('JobId') is not None:
+            self.job_id = m.get('JobId')
+        if m.get('JobOperationType') is not None:
+            self.job_operation_type = m.get('JobOperationType')
+        if m.get('RegionId') is not None:
+            self.region_id = m.get('RegionId')
         return self
 
 
-class GetJobResponseBodyJobInfo(TeaModel):
+class ListActionPlanActivitiesResponseBodyActionPlanActivities(TeaModel):
     def __init__(
         self,
-        app_extra_info: str = None,
-        create_time: str = None,
-        dependency_policy: GetJobResponseBodyJobInfoDependencyPolicy = None,
-        deployment_policy: GetJobResponseBodyJobInfoDeploymentPolicy = None,
+        action_plan_activity_id: str = None,
+        created_capacity: float = None,
+        destroy_capacity: float = None,
         end_time: str = None,
-        job_description: str = None,
-        job_id: str = None,
-        job_name: str = None,
-        job_scheduler: str = None,
+        jobs: List[ListActionPlanActivitiesResponseBodyActionPlanActivitiesJobs] = None,
         start_time: str = None,
         status: str = None,
-        tasks: List[GetJobResponseBodyJobInfoTasks] = None,
     ):
-        self.app_extra_info = app_extra_info
-        self.create_time = create_time
-        self.dependency_policy = dependency_policy
-        self.deployment_policy = deployment_policy
+        self.action_plan_activity_id = action_plan_activity_id
+        self.created_capacity = created_capacity
+        self.destroy_capacity = destroy_capacity
         self.end_time = end_time
-        self.job_description = job_description
-        self.job_id = job_id
-        self.job_name = job_name
-        self.job_scheduler = job_scheduler
+        self.jobs = jobs
         self.start_time = start_time
         self.status = status
-        self.tasks = tasks
 
     def validate(self):
-        if self.dependency_policy:
-            self.dependency_policy.validate()
-        if self.deployment_policy:
-            self.deployment_policy.validate()
-        if self.tasks:
-            for k in self.tasks:
+        if self.jobs:
+            for k in self.jobs:
                 if k:
                     k.validate()
 
@@ -3772,80 +4893,67 @@ class GetJobResponseBodyJobInfo(TeaModel):
             return _map
 
         result = dict()
-        if self.app_extra_info is not None:
-            result['AppExtraInfo'] = self.app_extra_info
-        if self.create_time is not None:
-            result['CreateTime'] = self.create_time
-        if self.dependency_policy is not None:
-            result['DependencyPolicy'] = self.dependency_policy.to_map()
-        if self.deployment_policy is not None:
-            result['DeploymentPolicy'] = self.deployment_policy.to_map()
+        if self.action_plan_activity_id is not None:
+            result['ActionPlanActivityId'] = self.action_plan_activity_id
+        if self.created_capacity is not None:
+            result['CreatedCapacity'] = self.created_capacity
+        if self.destroy_capacity is not None:
+            result['DestroyCapacity'] = self.destroy_capacity
         if self.end_time is not None:
             result['EndTime'] = self.end_time
-        if self.job_description is not None:
-            result['JobDescription'] = self.job_description
-        if self.job_id is not None:
-            result['JobId'] = self.job_id
-        if self.job_name is not None:
-            result['JobName'] = self.job_name
-        if self.job_scheduler is not None:
-            result['JobScheduler'] = self.job_scheduler
+        result['Jobs'] = []
+        if self.jobs is not None:
+            for k in self.jobs:
+                result['Jobs'].append(k.to_map() if k else None)
         if self.start_time is not None:
             result['StartTime'] = self.start_time
         if self.status is not None:
             result['Status'] = self.status
-        result['Tasks'] = []
-        if self.tasks is not None:
-            for k in self.tasks:
-                result['Tasks'].append(k.to_map() if k else None)
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('AppExtraInfo') is not None:
-            self.app_extra_info = m.get('AppExtraInfo')
-        if m.get('CreateTime') is not None:
-            self.create_time = m.get('CreateTime')
-        if m.get('DependencyPolicy') is not None:
-            temp_model = GetJobResponseBodyJobInfoDependencyPolicy()
-            self.dependency_policy = temp_model.from_map(m['DependencyPolicy'])
-        if m.get('DeploymentPolicy') is not None:
-            temp_model = GetJobResponseBodyJobInfoDeploymentPolicy()
-            self.deployment_policy = temp_model.from_map(m['DeploymentPolicy'])
+        if m.get('ActionPlanActivityId') is not None:
+            self.action_plan_activity_id = m.get('ActionPlanActivityId')
+        if m.get('CreatedCapacity') is not None:
+            self.created_capacity = m.get('CreatedCapacity')
+        if m.get('DestroyCapacity') is not None:
+            self.destroy_capacity = m.get('DestroyCapacity')
         if m.get('EndTime') is not None:
             self.end_time = m.get('EndTime')
-        if m.get('JobDescription') is not None:
-            self.job_description = m.get('JobDescription')
-        if m.get('JobId') is not None:
-            self.job_id = m.get('JobId')
-        if m.get('JobName') is not None:
-            self.job_name = m.get('JobName')
-        if m.get('JobScheduler') is not None:
-            self.job_scheduler = m.get('JobScheduler')
+        self.jobs = []
+        if m.get('Jobs') is not None:
+            for k in m.get('Jobs'):
+                temp_model = ListActionPlanActivitiesResponseBodyActionPlanActivitiesJobs()
+                self.jobs.append(temp_model.from_map(k))
         if m.get('StartTime') is not None:
             self.start_time = m.get('StartTime')
         if m.get('Status') is not None:
             self.status = m.get('Status')
-        self.tasks = []
-        if m.get('Tasks') is not None:
-            for k in m.get('Tasks'):
-                temp_model = GetJobResponseBodyJobInfoTasks()
-                self.tasks.append(temp_model.from_map(k))
         return self
 
 
-class GetJobResponseBody(TeaModel):
+class ListActionPlanActivitiesResponseBody(TeaModel):
     def __init__(
         self,
-        job_info: GetJobResponseBodyJobInfo = None,
+        action_plan_activities: List[ListActionPlanActivitiesResponseBodyActionPlanActivities] = None,
+        max_results: int = None,
+        next_token: str = None,
         request_id: str = None,
+        total_count: int = None,
     ):
-        self.job_info = job_info
+        self.action_plan_activities = action_plan_activities
+        self.max_results = max_results
+        # This parameter is required.
+        self.next_token = next_token
         self.request_id = request_id
+        self.total_count = total_count
 
     def validate(self):
-        if self.job_info:
-            self.job_info.validate()
+        if self.action_plan_activities:
+            for k in self.action_plan_activities:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -3853,28 +4961,44 @@ class GetJobResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.job_info is not None:
-            result['JobInfo'] = self.job_info.to_map()
+        result['ActionPlanActivities'] = []
+        if self.action_plan_activities is not None:
+            for k in self.action_plan_activities:
+                result['ActionPlanActivities'].append(k.to_map() if k else None)
+        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.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: dict = None):
         m = m or dict()
-        if m.get('JobInfo') is not None:
-            temp_model = GetJobResponseBodyJobInfo()
-            self.job_info = temp_model.from_map(m['JobInfo'])
+        self.action_plan_activities = []
+        if m.get('ActionPlanActivities') is not None:
+            for k in m.get('ActionPlanActivities'):
+                temp_model = ListActionPlanActivitiesResponseBodyActionPlanActivities()
+                self.action_plan_activities.append(temp_model.from_map(k))
+        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('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 GetJobResponse(TeaModel):
+class ListActionPlanActivitiesResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetJobResponseBody = None,
+        body: ListActionPlanActivitiesResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -3905,18 +5029,21 @@ class GetJobResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GetJobResponseBody()
+            temp_model = ListActionPlanActivitiesResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetPoolRequest(TeaModel):
+class ListActionPlansRequest(TeaModel):
     def __init__(
         self,
-        pool_name: str = None,
+        action_plan_ids: List[str] = None,
+        max_results: int = None,
+        next_token: str = None,
     ):
-        # This parameter is required.
-        self.pool_name = pool_name
+        self.action_plan_ids = action_plan_ids
+        self.max_results = max_results
+        self.next_token = next_token
 
     def validate(self):
         pass
@@ -3927,37 +5054,76 @@ class GetPoolRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.pool_name is not None:
-            result['PoolName'] = self.pool_name
+        if self.action_plan_ids is not None:
+            result['ActionPlanIds'] = self.action_plan_ids
+        if self.max_results is not None:
+            result['MaxResults'] = self.max_results
+        if self.next_token is not None:
+            result['NextToken'] = self.next_token
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('PoolName') is not None:
-            self.pool_name = m.get('PoolName')
+        if m.get('ActionPlanIds') is not None:
+            self.action_plan_ids = m.get('ActionPlanIds')
+        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')
         return self
 
 
-class GetPoolResponseBodyPoolInfo(TeaModel):
+class ListActionPlansShrinkRequest(TeaModel):
+    def __init__(
+        self,
+        action_plan_ids_shrink: str = None,
+        max_results: int = None,
+        next_token: str = None,
+    ):
+        self.action_plan_ids_shrink = action_plan_ids_shrink
+        self.max_results = max_results
+        self.next_token = next_token
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.action_plan_ids_shrink is not None:
+            result['ActionPlanIds'] = self.action_plan_ids_shrink
+        if self.max_results is not None:
+            result['MaxResults'] = self.max_results
+        if self.next_token is not None:
+            result['NextToken'] = self.next_token
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ActionPlanIds') is not None:
+            self.action_plan_ids_shrink = m.get('ActionPlanIds')
+        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')
+        return self
+
+
+class ListActionPlansResponseBodyActionPlans(TeaModel):
     def __init__(
         self,
+        action_plan_id: str = None,
+        action_plan_name: str = None,
         create_time: str = None,
-        exector_usage: int = None,
-        is_default: bool = None,
-        max_exector_num: int = None,
-        pool_name: str = None,
-        priority: int = None,
-        reason: str = None,
         status: str = None,
         update_time: str = None,
     ):
-        self.create_time = create_time
-        self.exector_usage = exector_usage
-        self.is_default = is_default
-        self.max_exector_num = max_exector_num
-        self.pool_name = pool_name
-        self.priority = priority
-        self.reason = reason
+        self.action_plan_id = action_plan_id
+        self.action_plan_name = action_plan_name
+        self.create_time = create_time
         self.status = status
         self.update_time = update_time
 
@@ -3970,20 +5136,12 @@ class GetPoolResponseBodyPoolInfo(TeaModel):
             return _map
 
         result = dict()
+        if self.action_plan_id is not None:
+            result['ActionPlanId'] = self.action_plan_id
+        if self.action_plan_name is not None:
+            result['ActionPlanName'] = self.action_plan_name
         if self.create_time is not None:
             result['CreateTime'] = self.create_time
-        if self.exector_usage is not None:
-            result['ExectorUsage'] = self.exector_usage
-        if self.is_default is not None:
-            result['IsDefault'] = self.is_default
-        if self.max_exector_num is not None:
-            result['MaxExectorNum'] = self.max_exector_num
-        if self.pool_name is not None:
-            result['PoolName'] = self.pool_name
-        if self.priority is not None:
-            result['Priority'] = self.priority
-        if self.reason is not None:
-            result['Reason'] = self.reason
         if self.status is not None:
             result['Status'] = self.status
         if self.update_time is not None:
@@ -3992,20 +5150,12 @@ class GetPoolResponseBodyPoolInfo(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('ActionPlanId') is not None:
+            self.action_plan_id = m.get('ActionPlanId')
+        if m.get('ActionPlanName') is not None:
+            self.action_plan_name = m.get('ActionPlanName')
         if m.get('CreateTime') is not None:
             self.create_time = m.get('CreateTime')
-        if m.get('ExectorUsage') is not None:
-            self.exector_usage = m.get('ExectorUsage')
-        if m.get('IsDefault') is not None:
-            self.is_default = m.get('IsDefault')
-        if m.get('MaxExectorNum') is not None:
-            self.max_exector_num = m.get('MaxExectorNum')
-        if m.get('PoolName') is not None:
-            self.pool_name = m.get('PoolName')
-        if m.get('Priority') is not None:
-            self.priority = m.get('Priority')
-        if m.get('Reason') is not None:
-            self.reason = m.get('Reason')
         if m.get('Status') is not None:
             self.status = m.get('Status')
         if m.get('UpdateTime') is not None:
@@ -4013,19 +5163,27 @@ class GetPoolResponseBodyPoolInfo(TeaModel):
         return self
 
 
-class GetPoolResponseBody(TeaModel):
+class ListActionPlansResponseBody(TeaModel):
     def __init__(
         self,
-        pool_info: GetPoolResponseBodyPoolInfo = None,
+        action_plans: List[ListActionPlansResponseBodyActionPlans] = None,
+        max_results: int = None,
+        next_token: str = None,
         request_id: str = None,
+        total_count: int = None,
     ):
-        self.pool_info = pool_info
-        # Id of the request
+        self.action_plans = action_plans
+        self.max_results = max_results
+        # This parameter is required.
+        self.next_token = next_token
         self.request_id = request_id
+        self.total_count = total_count
 
     def validate(self):
-        if self.pool_info:
-            self.pool_info.validate()
+        if self.action_plans:
+            for k in self.action_plans:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -4033,28 +5191,44 @@ class GetPoolResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.pool_info is not None:
-            result['PoolInfo'] = self.pool_info.to_map()
+        result['ActionPlans'] = []
+        if self.action_plans is not None:
+            for k in self.action_plans:
+                result['ActionPlans'].append(k.to_map() if k else None)
+        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.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: dict = None):
         m = m or dict()
-        if m.get('PoolInfo') is not None:
-            temp_model = GetPoolResponseBodyPoolInfo()
-            self.pool_info = temp_model.from_map(m['PoolInfo'])
+        self.action_plans = []
+        if m.get('ActionPlans') is not None:
+            for k in m.get('ActionPlans'):
+                temp_model = ListActionPlansResponseBodyActionPlans()
+                self.action_plans.append(temp_model.from_map(k))
+        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('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 GetPoolResponse(TeaModel):
+class ListActionPlansResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetPoolResponseBody = None,
+        body: ListActionPlansResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -4085,7 +5259,7 @@ class GetPoolResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GetPoolResponseBody()
+            temp_model = ListActionPlansResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -6402,6 +7576,142 @@ class RemoveImageResponse(TeaModel):
         return self
 
 
+class SynchronizeAppRequest(TeaModel):
+    def __init__(
+        self,
+        app_id: str = None,
+        target_region_ids: List[str] = None,
+    ):
+        # This parameter is required.
+        self.app_id = app_id
+        self.target_region_ids = target_region_ids
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.app_id is not None:
+            result['AppId'] = self.app_id
+        if self.target_region_ids is not None:
+            result['TargetRegionIds'] = self.target_region_ids
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AppId') is not None:
+            self.app_id = m.get('AppId')
+        if m.get('TargetRegionIds') is not None:
+            self.target_region_ids = m.get('TargetRegionIds')
+        return self
+
+
+class SynchronizeAppShrinkRequest(TeaModel):
+    def __init__(
+        self,
+        app_id: str = None,
+        target_region_ids_shrink: str = None,
+    ):
+        # This parameter is required.
+        self.app_id = app_id
+        self.target_region_ids_shrink = target_region_ids_shrink
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.app_id is not None:
+            result['AppId'] = self.app_id
+        if self.target_region_ids_shrink is not None:
+            result['TargetRegionIds'] = self.target_region_ids_shrink
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('AppId') is not None:
+            self.app_id = m.get('AppId')
+        if m.get('TargetRegionIds') is not None:
+            self.target_region_ids_shrink = m.get('TargetRegionIds')
+        return self
+
+
+class SynchronizeAppResponseBody(TeaModel):
+    def __init__(
+        self,
+        request_id: str = None,
+    ):
+        self.request_id = request_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().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: dict = None):
+        m = m or dict()
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        return self
+
+
+class SynchronizeAppResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: SynchronizeAppResponseBody = 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 = SynchronizeAppResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class TagResourcesRequestTag(TeaModel):
     def __init__(
         self,
@@ -6669,6 +7979,113 @@ class UnTagResourcesResponse(TeaModel):
         return self
 
 
+class UpdateActionPlanRequest(TeaModel):
+    def __init__(
+        self,
+        action_plan_id: str = None,
+        desired_capacity: float = None,
+        enabled: str = None,
+    ):
+        self.action_plan_id = action_plan_id
+        self.desired_capacity = desired_capacity
+        self.enabled = enabled
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.action_plan_id is not None:
+            result['ActionPlanId'] = self.action_plan_id
+        if self.desired_capacity is not None:
+            result['DesiredCapacity'] = self.desired_capacity
+        if self.enabled is not None:
+            result['Enabled'] = self.enabled
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ActionPlanId') is not None:
+            self.action_plan_id = m.get('ActionPlanId')
+        if m.get('DesiredCapacity') is not None:
+            self.desired_capacity = m.get('DesiredCapacity')
+        if m.get('Enabled') is not None:
+            self.enabled = m.get('Enabled')
+        return self
+
+
+class UpdateActionPlanResponseBody(TeaModel):
+    def __init__(
+        self,
+        request_id: str = None,
+    ):
+        self.request_id = request_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().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: dict = None):
+        m = m or dict()
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        return self
+
+
+class UpdateActionPlanResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: UpdateActionPlanResponseBody = 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 = UpdateActionPlanResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class UpdatePoolRequestResourceLimits(TeaModel):
     def __init__(
         self,