alibabacloud-ehpcinstant20230701 3.1.0__py3-none-any.whl → 3.2.1__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,
@@ -696,11 +1027,15 @@ class CreateJobRequestTasksTaskSpecResource(TeaModel):
         self,
         cores: float = None,
         disks: List[CreateJobRequestTasksTaskSpecResourceDisks] = None,
+        enable_ht: bool = None,
+        host_name_prefix: str = None,
         instance_types: List[str] = None,
         memory: float = None,
     ):
         self.cores = cores
         self.disks = disks
+        self.enable_ht = enable_ht
+        self.host_name_prefix = host_name_prefix
         self.instance_types = instance_types
         self.memory = memory
 
@@ -722,6 +1057,10 @@ class CreateJobRequestTasksTaskSpecResource(TeaModel):
         if self.disks is not None:
             for k in self.disks:
                 result['Disks'].append(k.to_map() if k else None)
+        if self.enable_ht is not None:
+            result['EnableHT'] = self.enable_ht
+        if self.host_name_prefix is not None:
+            result['HostNamePrefix'] = self.host_name_prefix
         if self.instance_types is not None:
             result['InstanceTypes'] = self.instance_types
         if self.memory is not None:
@@ -737,6 +1076,10 @@ class CreateJobRequestTasksTaskSpecResource(TeaModel):
             for k in m.get('Disks'):
                 temp_model = CreateJobRequestTasksTaskSpecResourceDisks()
                 self.disks.append(temp_model.from_map(k))
+        if m.get('EnableHT') is not None:
+            self.enable_ht = m.get('EnableHT')
+        if m.get('HostNamePrefix') is not None:
+            self.host_name_prefix = m.get('HostNamePrefix')
         if m.get('InstanceTypes') is not None:
             self.instance_types = m.get('InstanceTypes')
         if m.get('Memory') is not None:
@@ -1619,14 +1962,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 +1978,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 +2745,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 +2761,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 +2792,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 +2829,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 +2895,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 +2993,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 +3038,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 +3088,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 +3134,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 +3191,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
@@ -3419,11 +4125,15 @@ class GetJobResponseBodyJobInfoTasksTaskSpecResource(TeaModel):
         self,
         cores: float = None,
         disks: List[GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks] = None,
+        enable_ht: bool = None,
+        host_name_prefix: str = None,
         instance_types: List[str] = None,
         memory: int = None,
     ):
         self.cores = cores
         self.disks = disks
+        self.enable_ht = enable_ht
+        self.host_name_prefix = host_name_prefix
         self.instance_types = instance_types
         self.memory = memory
 
@@ -3445,6 +4155,10 @@ class GetJobResponseBodyJobInfoTasksTaskSpecResource(TeaModel):
         if self.disks is not None:
             for k in self.disks:
                 result['Disks'].append(k.to_map() if k else None)
+        if self.enable_ht is not None:
+            result['EnableHT'] = self.enable_ht
+        if self.host_name_prefix is not None:
+            result['HostNamePrefix'] = self.host_name_prefix
         if self.instance_types is not None:
             result['InstanceTypes'] = self.instance_types
         if self.memory is not None:
@@ -3460,6 +4174,10 @@ class GetJobResponseBodyJobInfoTasksTaskSpecResource(TeaModel):
             for k in m.get('Disks'):
                 temp_model = GetJobResponseBodyJobInfoTasksTaskSpecResourceDisks()
                 self.disks.append(temp_model.from_map(k))
+        if m.get('EnableHT') is not None:
+            self.enable_ht = m.get('EnableHT')
+        if m.get('HostNamePrefix') is not None:
+            self.host_name_prefix = m.get('HostNamePrefix')
         if m.get('InstanceTypes') is not None:
             self.instance_types = m.get('InstanceTypes')
         if m.get('Memory') is not None:
@@ -3802,50 +4520,464 @@ class GetJobResponseBodyJobInfo(TeaModel):
 
     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('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 GetJobResponseBody(TeaModel):
+    def __init__(
+        self,
+        job_info: GetJobResponseBodyJobInfo = None,
+        request_id: str = None,
+    ):
+        self.job_info = job_info
+        self.request_id = request_id
+
+    def validate(self):
+        if self.job_info:
+            self.job_info.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        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('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 GetJobResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetJobResponseBody = 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 = GetJobResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetPoolRequest(TeaModel):
+    def __init__(
+        self,
+        pool_name: str = None,
+    ):
+        # This parameter is required.
+        self.pool_name = pool_name
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        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('PoolName') is not None:
+            self.pool_name = m.get('PoolName')
+        return self
+
+
+class GetPoolResponseBodyPoolInfo(TeaModel):
+    def __init__(
+        self,
+        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.status = status
+        self.update_time = update_time
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        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()
+        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 GetPoolResponseBody(TeaModel):
+    def __init__(
+        self,
+        pool_info: GetPoolResponseBodyPoolInfo = None,
+        request_id: str = None,
+    ):
+        self.pool_info = pool_info
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        if self.pool_info:
+            self.pool_info.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        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('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 GetPoolResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetPoolResponseBody = 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 = GetPoolResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListActionPlanActivitiesRequest(TeaModel):
+    def __init__(
+        self,
+        action_plan_id: str = None,
+        max_results: int = None,
+        next_token: str = None,
+    ):
+        self.action_plan_id = action_plan_id
+        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_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('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 ListActionPlanActivitiesResponseBodyActionPlanActivitiesJobs(TeaModel):
+    def __init__(
+        self,
+        job_id: str = None,
+        job_operation_type: str = None,
+        region_id: str = None,
+    ):
+        self.job_id = job_id
+        self.job_operation_type = job_operation_type
+        self.region_id = region_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        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('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 ListActionPlanActivitiesResponseBodyActionPlanActivities(TeaModel):
+    def __init__(
+        self,
+        action_plan_activity_id: str = None,
+        created_capacity: float = None,
+        destroy_capacity: float = None,
+        end_time: str = None,
+        jobs: List[ListActionPlanActivitiesResponseBodyActionPlanActivitiesJobs] = None,
+        start_time: str = None,
+        status: str = None,
+    ):
+        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.jobs = jobs
+        self.start_time = start_time
+        self.status = status
+
+    def validate(self):
+        if self.jobs:
+            for k in self.jobs:
+                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_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
+        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
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        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 +4985,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 +5053,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 +5078,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.action_plan_id = action_plan_id
+        self.action_plan_name = action_plan_name
         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
 
@@ -3970,20 +5160,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 +5174,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 +5187,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 +5215,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 +5283,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
 
@@ -4361,6 +5559,7 @@ class ListExecutorsResponseBodyExecutorsTags(TeaModel):
 class ListExecutorsResponseBodyExecutors(TeaModel):
     def __init__(
         self,
+        allocation_spec: str = None,
         app_name: str = None,
         array_index: int = None,
         block_duration: int = None,
@@ -4385,6 +5584,7 @@ class ListExecutorsResponseBodyExecutors(TeaModel):
         task_sustainable: bool = None,
         vswitch_id: str = None,
     ):
+        self.allocation_spec = allocation_spec
         self.app_name = app_name
         self.array_index = array_index
         self.block_duration = block_duration
@@ -4423,6 +5623,8 @@ class ListExecutorsResponseBodyExecutors(TeaModel):
             return _map
 
         result = dict()
+        if self.allocation_spec is not None:
+            result['AllocationSpec'] = self.allocation_spec
         if self.app_name is not None:
             result['AppName'] = self.app_name
         if self.array_index is not None:
@@ -4475,6 +5677,8 @@ class ListExecutorsResponseBodyExecutors(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('AllocationSpec') is not None:
+            self.allocation_spec = m.get('AllocationSpec')
         if m.get('AppName') is not None:
             self.app_name = m.get('AppName')
         if m.get('ArrayIndex') is not None:
@@ -5106,6 +6310,7 @@ class ListJobExecutorsResponseBodyExecutorsTags(TeaModel):
 class ListJobExecutorsResponseBodyExecutors(TeaModel):
     def __init__(
         self,
+        allocation_spec: str = None,
         array_index: int = None,
         block_duration: int = None,
         create_time: str = None,
@@ -5121,6 +6326,7 @@ class ListJobExecutorsResponseBodyExecutors(TeaModel):
         status_reason: str = None,
         tags: List[ListJobExecutorsResponseBodyExecutorsTags] = None,
     ):
+        self.allocation_spec = allocation_spec
         self.array_index = array_index
         self.block_duration = block_duration
         self.create_time = create_time
@@ -5148,6 +6354,8 @@ class ListJobExecutorsResponseBodyExecutors(TeaModel):
             return _map
 
         result = dict()
+        if self.allocation_spec is not None:
+            result['AllocationSpec'] = self.allocation_spec
         if self.array_index is not None:
             result['ArrayIndex'] = self.array_index
         if self.block_duration is not None:
@@ -5182,6 +6390,8 @@ class ListJobExecutorsResponseBodyExecutors(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('AllocationSpec') is not None:
+            self.allocation_spec = m.get('AllocationSpec')
         if m.get('ArrayIndex') is not None:
             self.array_index = m.get('ArrayIndex')
         if m.get('BlockDuration') is not None:
@@ -6805,6 +8015,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,