alibabacloud-fc20230330 4.3.0__py3-none-any.whl → 4.4.0__py3-none-any.whl

alibabacloud_fc20230330/models.py

@@ -535,6 +535,84 @@ class CertConfig(TeaModel):
         return self
 
 
+class ChangeResourceGroupInput(TeaModel):
+    def __init__(
+        self,
+        new_resource_group_id: str = None,
+        resource_id: str = None,
+        resource_type: str = None,
+    ):
+        self.new_resource_group_id = new_resource_group_id
+        self.resource_id = resource_id
+        self.resource_type = resource_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.new_resource_group_id is not None:
+            result['newResourceGroupId'] = self.new_resource_group_id
+        if self.resource_id is not None:
+            result['resourceId'] = self.resource_id
+        if self.resource_type is not None:
+            result['resourceType'] = self.resource_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('newResourceGroupId') is not None:
+            self.new_resource_group_id = m.get('newResourceGroupId')
+        if m.get('resourceId') is not None:
+            self.resource_id = m.get('resourceId')
+        if m.get('resourceType') is not None:
+            self.resource_type = m.get('resourceType')
+        return self
+
+
+class ChangeResourceGroupOutput(TeaModel):
+    def __init__(
+        self,
+        new_resource_group_id: str = None,
+        old_resource_group_id: str = None,
+        resource_id: str = None,
+    ):
+        self.new_resource_group_id = new_resource_group_id
+        self.old_resource_group_id = old_resource_group_id
+        self.resource_id = resource_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.new_resource_group_id is not None:
+            result['newResourceGroupId'] = self.new_resource_group_id
+        if self.old_resource_group_id is not None:
+            result['oldResourceGroupId'] = self.old_resource_group_id
+        if self.resource_id is not None:
+            result['resourceId'] = self.resource_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('newResourceGroupId') is not None:
+            self.new_resource_group_id = m.get('newResourceGroupId')
+        if m.get('oldResourceGroupId') is not None:
+            self.old_resource_group_id = m.get('oldResourceGroupId')
+        if m.get('resourceId') is not None:
+            self.resource_id = m.get('resourceId')
+        return self
+
+
 class ConcurrencyConfig(TeaModel):
     def __init__(
         self,
@@ -568,6 +646,45 @@ class ConcurrencyConfig(TeaModel):
         return self
 
 
+class CookieSessionAffinityConfig(TeaModel):
+    def __init__(
+        self,
+        session_concurrency_per_instance: int = None,
+        session_idle_timeout_in_seconds: int = None,
+        session_ttlin_seconds: int = None,
+    ):
+        self.session_concurrency_per_instance = session_concurrency_per_instance
+        self.session_idle_timeout_in_seconds = session_idle_timeout_in_seconds
+        self.session_ttlin_seconds = session_ttlin_seconds
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.session_concurrency_per_instance is not None:
+            result['sessionConcurrencyPerInstance'] = self.session_concurrency_per_instance
+        if self.session_idle_timeout_in_seconds is not None:
+            result['sessionIdleTimeoutInSeconds'] = self.session_idle_timeout_in_seconds
+        if self.session_ttlin_seconds is not None:
+            result['sessionTTLInSeconds'] = self.session_ttlin_seconds
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('sessionConcurrencyPerInstance') is not None:
+            self.session_concurrency_per_instance = m.get('sessionConcurrencyPerInstance')
+        if m.get('sessionIdleTimeoutInSeconds') is not None:
+            self.session_idle_timeout_in_seconds = m.get('sessionIdleTimeoutInSeconds')
+        if m.get('sessionTTLInSeconds') is not None:
+            self.session_ttlin_seconds = m.get('sessionTTLInSeconds')
+        return self
+
+
 class CreateAliasInput(TeaModel):
     def __init__(
         self,
@@ -1527,9 +1644,11 @@ class GPUConfig(TeaModel):
 class LifecycleHook(TeaModel):
     def __init__(
         self,
+        command: List[str] = None,
         handler: str = None,
         timeout: int = None,
     ):
+        self.command = command
         self.handler = handler
         self.timeout = timeout
 
@@ -1542,6 +1661,8 @@ class LifecycleHook(TeaModel):
             return _map
 
         result = dict()
+        if self.command is not None:
+            result['command'] = self.command
         if self.handler is not None:
             result['handler'] = self.handler
         if self.timeout is not None:
@@ -1550,6 +1671,8 @@ class LifecycleHook(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('command') is not None:
+            self.command = m.get('command')
         if m.get('handler') is not None:
             self.handler = m.get('handler')
         if m.get('timeout') is not None:
@@ -1940,11 +2063,13 @@ class CreateFunctionInput(TeaModel):
         description: str = None,
         disable_ondemand: bool = None,
         disk_size: int = None,
+        enable_long_living: bool = None,
         environment_variables: Dict[str, str] = None,
         function_name: str = None,
         gpu_config: GPUConfig = None,
         handler: str = None,
         instance_concurrency: int = None,
+        instance_isolation_mode: str = None,
         instance_lifecycle_config: InstanceLifecycleConfig = None,
         internet_access: bool = None,
         layers: List[str] = None,
@@ -1952,8 +2077,11 @@ class CreateFunctionInput(TeaModel):
         memory_size: int = None,
         nas_config: NASConfig = None,
         oss_mount_config: OSSMountConfig = None,
+        resource_group_id: str = None,
         role: str = None,
         runtime: str = None,
+        session_affinity: str = None,
+        session_affinity_config: str = None,
         tags: List[Tag] = None,
         timeout: int = None,
         tracing_config: TracingConfig = None,
@@ -1967,6 +2095,7 @@ class CreateFunctionInput(TeaModel):
         self.description = description
         self.disable_ondemand = disable_ondemand
         self.disk_size = disk_size
+        self.enable_long_living = enable_long_living
         self.environment_variables = environment_variables
         # This parameter is required.
         self.function_name = function_name
@@ -1974,6 +2103,7 @@ class CreateFunctionInput(TeaModel):
         # This parameter is required.
         self.handler = handler
         self.instance_concurrency = instance_concurrency
+        self.instance_isolation_mode = instance_isolation_mode
         self.instance_lifecycle_config = instance_lifecycle_config
         self.internet_access = internet_access
         self.layers = layers
@@ -1981,9 +2111,12 @@ class CreateFunctionInput(TeaModel):
         self.memory_size = memory_size
         self.nas_config = nas_config
         self.oss_mount_config = oss_mount_config
+        self.resource_group_id = resource_group_id
         self.role = role
         # This parameter is required.
         self.runtime = runtime
+        self.session_affinity = session_affinity
+        self.session_affinity_config = session_affinity_config
         self.tags = tags
         self.timeout = timeout
         self.tracing_config = tracing_config
@@ -2039,6 +2172,8 @@ class CreateFunctionInput(TeaModel):
             result['disableOndemand'] = self.disable_ondemand
         if self.disk_size is not None:
             result['diskSize'] = self.disk_size
+        if self.enable_long_living is not None:
+            result['enableLongLiving'] = self.enable_long_living
         if self.environment_variables is not None:
             result['environmentVariables'] = self.environment_variables
         if self.function_name is not None:
@@ -2049,6 +2184,8 @@ class CreateFunctionInput(TeaModel):
             result['handler'] = self.handler
         if self.instance_concurrency is not None:
             result['instanceConcurrency'] = self.instance_concurrency
+        if self.instance_isolation_mode is not None:
+            result['instanceIsolationMode'] = self.instance_isolation_mode
         if self.instance_lifecycle_config is not None:
             result['instanceLifecycleConfig'] = self.instance_lifecycle_config.to_map()
         if self.internet_access is not None:
@@ -2063,10 +2200,16 @@ class CreateFunctionInput(TeaModel):
             result['nasConfig'] = self.nas_config.to_map()
         if self.oss_mount_config is not None:
             result['ossMountConfig'] = self.oss_mount_config.to_map()
+        if self.resource_group_id is not None:
+            result['resourceGroupId'] = self.resource_group_id
         if self.role is not None:
             result['role'] = self.role
         if self.runtime is not None:
             result['runtime'] = self.runtime
+        if self.session_affinity is not None:
+            result['sessionAffinity'] = self.session_affinity
+        if self.session_affinity_config is not None:
+            result['sessionAffinityConfig'] = self.session_affinity_config
         result['tags'] = []
         if self.tags is not None:
             for k in self.tags:
@@ -2101,6 +2244,8 @@ class CreateFunctionInput(TeaModel):
             self.disable_ondemand = m.get('disableOndemand')
         if m.get('diskSize') is not None:
             self.disk_size = m.get('diskSize')
+        if m.get('enableLongLiving') is not None:
+            self.enable_long_living = m.get('enableLongLiving')
         if m.get('environmentVariables') is not None:
             self.environment_variables = m.get('environmentVariables')
         if m.get('functionName') is not None:
@@ -2112,6 +2257,8 @@ class CreateFunctionInput(TeaModel):
             self.handler = m.get('handler')
         if m.get('instanceConcurrency') is not None:
             self.instance_concurrency = m.get('instanceConcurrency')
+        if m.get('instanceIsolationMode') is not None:
+            self.instance_isolation_mode = m.get('instanceIsolationMode')
         if m.get('instanceLifecycleConfig') is not None:
             temp_model = InstanceLifecycleConfig()
             self.instance_lifecycle_config = temp_model.from_map(m['instanceLifecycleConfig'])
@@ -2130,10 +2277,16 @@ class CreateFunctionInput(TeaModel):
         if m.get('ossMountConfig') is not None:
             temp_model = OSSMountConfig()
             self.oss_mount_config = temp_model.from_map(m['ossMountConfig'])
+        if m.get('resourceGroupId') is not None:
+            self.resource_group_id = m.get('resourceGroupId')
         if m.get('role') is not None:
             self.role = m.get('role')
         if m.get('runtime') is not None:
             self.runtime = m.get('runtime')
+        if m.get('sessionAffinity') is not None:
+            self.session_affinity = m.get('sessionAffinity')
+        if m.get('sessionAffinityConfig') is not None:
+            self.session_affinity_config = m.get('sessionAffinityConfig')
         self.tags = []
         if m.get('tags') is not None:
             for k in m.get('tags'):
@@ -2458,16 +2611,14 @@ class DeliveryOption(TeaModel):
         return self
 
 
-class Error(TeaModel):
+class DescribeRegionsOutputRegionsRegion(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        message: str = None,
-        request_id: str = None,
+        local_name: str = None,
+        region_id: str = None,
     ):
-        self.code = code
-        self.message = message
-        self.request_id = request_id
+        self.local_name = local_name
+        self.region_id = region_id
 
     def validate(self):
         pass
@@ -2478,35 +2629,33 @@ class Error(TeaModel):
             return _map
 
         result = dict()
-        if self.code is not None:
-            result['Code'] = self.code
-        if self.message is not None:
-            result['Message'] = self.message
-        if self.request_id is not None:
-            result['RequestId'] = self.request_id
+        if self.local_name is not None:
+            result['LocalName'] = self.local_name
+        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('Code') is not None:
-            self.code = m.get('Code')
-        if m.get('Message') is not None:
-            self.message = m.get('Message')
-        if m.get('RequestId') is not None:
-            self.request_id = m.get('RequestId')
+        if m.get('LocalName') is not None:
+            self.local_name = m.get('LocalName')
+        if m.get('RegionId') is not None:
+            self.region_id = m.get('RegionId')
         return self
 
 
-class EventSinkConfig(TeaModel):
+class DescribeRegionsOutputRegions(TeaModel):
     def __init__(
         self,
-        delivery_option: DeliveryOption = None,
+        region: List[DescribeRegionsOutputRegionsRegion] = None,
     ):
-        self.delivery_option = delivery_option
+        self.region = region
 
     def validate(self):
-        if self.delivery_option:
-            self.delivery_option.validate()
+        if self.region:
+            for k in self.region:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -2514,41 +2663,32 @@ class EventSinkConfig(TeaModel):
             return _map
 
         result = dict()
-        if self.delivery_option is not None:
-            result['deliveryOption'] = self.delivery_option.to_map()
+        result['Region'] = []
+        if self.region is not None:
+            for k in self.region:
+                result['Region'].append(k.to_map() if k else None)
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('deliveryOption') is not None:
-            temp_model = DeliveryOption()
-            self.delivery_option = temp_model.from_map(m['deliveryOption'])
+        self.region = []
+        if m.get('Region') is not None:
+            for k in m.get('Region'):
+                temp_model = DescribeRegionsOutputRegionsRegion()
+                self.region.append(temp_model.from_map(k))
         return self
 
 
-class SourceDTSParameters(TeaModel):
+class DescribeRegionsOutput(TeaModel):
     def __init__(
         self,
-        broker_url: str = None,
-        init_check_point: int = None,
-        password: str = None,
-        region_id: str = None,
-        sid: str = None,
-        task_id: str = None,
-        topic: str = None,
-        username: str = None,
+        regions: DescribeRegionsOutputRegions = None,
     ):
-        self.broker_url = broker_url
-        self.init_check_point = init_check_point
-        self.password = password
-        self.region_id = region_id
-        self.sid = sid
-        self.task_id = task_id
-        self.topic = topic
-        self.username = username
+        self.regions = regions
 
     def validate(self):
-        pass
+        if self.regions:
+            self.regions.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -2556,67 +2696,38 @@ class SourceDTSParameters(TeaModel):
             return _map
 
         result = dict()
-        if self.broker_url is not None:
-            result['BrokerUrl'] = self.broker_url
-        if self.init_check_point is not None:
-            result['InitCheckPoint'] = self.init_check_point
-        if self.password is not None:
-            result['Password'] = self.password
-        if self.region_id is not None:
-            result['RegionId'] = self.region_id
-        if self.sid is not None:
-            result['Sid'] = self.sid
-        if self.task_id is not None:
-            result['TaskId'] = self.task_id
-        if self.topic is not None:
-            result['Topic'] = self.topic
-        if self.username is not None:
-            result['Username'] = self.username
+        if self.regions is not None:
+            result['Regions'] = self.regions.to_map()
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('BrokerUrl') is not None:
-            self.broker_url = m.get('BrokerUrl')
-        if m.get('InitCheckPoint') is not None:
-            self.init_check_point = m.get('InitCheckPoint')
-        if m.get('Password') is not None:
-            self.password = m.get('Password')
-        if m.get('RegionId') is not None:
-            self.region_id = m.get('RegionId')
-        if m.get('Sid') is not None:
-            self.sid = m.get('Sid')
-        if m.get('TaskId') is not None:
-            self.task_id = m.get('TaskId')
-        if m.get('Topic') is not None:
-            self.topic = m.get('Topic')
-        if m.get('Username') is not None:
-            self.username = m.get('Username')
+        if m.get('Regions') is not None:
+            temp_model = DescribeRegionsOutputRegions()
+            self.regions = temp_model.from_map(m['Regions'])
         return self
 
 
-class SourceKafkaParameters(TeaModel):
+class ScalingPolicy(TeaModel):
     def __init__(
         self,
-        consumer_group: str = None,
-        instance_id: str = None,
-        network: str = None,
-        offset_reset: str = None,
-        region_id: str = None,
-        security_group_id: str = None,
-        topic: str = None,
-        v_switch_ids: str = None,
-        vpc_id: str = None,
+        end_time: str = None,
+        max_instances: int = None,
+        metric_target: float = None,
+        metric_type: str = None,
+        min_instances: int = None,
+        name: str = None,
+        start_time: str = None,
+        time_zone: str = None,
     ):
-        self.consumer_group = consumer_group
-        self.instance_id = instance_id
-        self.network = network
-        self.offset_reset = offset_reset
-        self.region_id = region_id
-        self.security_group_id = security_group_id
-        self.topic = topic
-        self.v_switch_ids = v_switch_ids
-        self.vpc_id = vpc_id
+        self.end_time = end_time
+        self.max_instances = max_instances
+        self.metric_target = metric_target
+        self.metric_type = metric_type
+        self.min_instances = min_instances
+        self.name = name
+        self.start_time = start_time
+        self.time_zone = time_zone
 
     def validate(self):
         pass
@@ -2627,37 +2738,382 @@ class SourceKafkaParameters(TeaModel):
             return _map
 
         result = dict()
-        if self.consumer_group is not None:
-            result['ConsumerGroup'] = self.consumer_group
-        if self.instance_id is not None:
-            result['InstanceId'] = self.instance_id
-        if self.network is not None:
-            result['Network'] = self.network
-        if self.offset_reset is not None:
-            result['OffsetReset'] = self.offset_reset
-        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.topic is not None:
-            result['Topic'] = self.topic
-        if self.v_switch_ids is not None:
-            result['VSwitchIds'] = self.v_switch_ids
-        if self.vpc_id is not None:
-            result['VpcId'] = self.vpc_id
+        if self.end_time is not None:
+            result['endTime'] = self.end_time
+        if self.max_instances is not None:
+            result['maxInstances'] = self.max_instances
+        if self.metric_target is not None:
+            result['metricTarget'] = self.metric_target
+        if self.metric_type is not None:
+            result['metricType'] = self.metric_type
+        if self.min_instances is not None:
+            result['minInstances'] = self.min_instances
+        if self.name is not None:
+            result['name'] = self.name
+        if self.start_time is not None:
+            result['startTime'] = self.start_time
+        if self.time_zone is not None:
+            result['timeZone'] = self.time_zone
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('ConsumerGroup') is not None:
-            self.consumer_group = m.get('ConsumerGroup')
-        if m.get('InstanceId') is not None:
-            self.instance_id = m.get('InstanceId')
-        if m.get('Network') is not None:
-            self.network = m.get('Network')
-        if m.get('OffsetReset') is not None:
-            self.offset_reset = m.get('OffsetReset')
-        if m.get('RegionId') is not None:
+        if m.get('endTime') is not None:
+            self.end_time = m.get('endTime')
+        if m.get('maxInstances') is not None:
+            self.max_instances = m.get('maxInstances')
+        if m.get('metricTarget') is not None:
+            self.metric_target = m.get('metricTarget')
+        if m.get('metricType') is not None:
+            self.metric_type = m.get('metricType')
+        if m.get('minInstances') is not None:
+            self.min_instances = m.get('minInstances')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('startTime') is not None:
+            self.start_time = m.get('startTime')
+        if m.get('timeZone') is not None:
+            self.time_zone = m.get('timeZone')
+        return self
+
+
+class ScheduledPolicy(TeaModel):
+    def __init__(
+        self,
+        end_time: str = None,
+        name: str = None,
+        schedule_expression: str = None,
+        start_time: str = None,
+        target: int = None,
+        time_zone: str = None,
+    ):
+        self.end_time = end_time
+        self.name = name
+        self.schedule_expression = schedule_expression
+        self.start_time = start_time
+        self.target = target
+        self.time_zone = time_zone
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.end_time is not None:
+            result['endTime'] = self.end_time
+        if self.name is not None:
+            result['name'] = self.name
+        if self.schedule_expression is not None:
+            result['scheduleExpression'] = self.schedule_expression
+        if self.start_time is not None:
+            result['startTime'] = self.start_time
+        if self.target is not None:
+            result['target'] = self.target
+        if self.time_zone is not None:
+            result['timeZone'] = self.time_zone
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('endTime') is not None:
+            self.end_time = m.get('endTime')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('scheduleExpression') is not None:
+            self.schedule_expression = m.get('scheduleExpression')
+        if m.get('startTime') is not None:
+            self.start_time = m.get('startTime')
+        if m.get('target') is not None:
+            self.target = m.get('target')
+        if m.get('timeZone') is not None:
+            self.time_zone = m.get('timeZone')
+        return self
+
+
+class ElasticConfigStatus(TeaModel):
+    def __init__(
+        self,
+        current_error: str = None,
+        current_instances: int = None,
+        function_arn: str = None,
+        min_instances: int = None,
+        resident_pool_id: str = None,
+        scaling_policies: List[ScalingPolicy] = None,
+        scheduled_policies: List[ScheduledPolicy] = None,
+    ):
+        self.current_error = current_error
+        self.current_instances = current_instances
+        self.function_arn = function_arn
+        self.min_instances = min_instances
+        self.resident_pool_id = resident_pool_id
+        self.scaling_policies = scaling_policies
+        self.scheduled_policies = scheduled_policies
+
+    def validate(self):
+        if self.scaling_policies:
+            for k in self.scaling_policies:
+                if k:
+                    k.validate()
+        if self.scheduled_policies:
+            for k in self.scheduled_policies:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.current_error is not None:
+            result['currentError'] = self.current_error
+        if self.current_instances is not None:
+            result['currentInstances'] = self.current_instances
+        if self.function_arn is not None:
+            result['functionArn'] = self.function_arn
+        if self.min_instances is not None:
+            result['minInstances'] = self.min_instances
+        if self.resident_pool_id is not None:
+            result['residentPoolId'] = self.resident_pool_id
+        result['scalingPolicies'] = []
+        if self.scaling_policies is not None:
+            for k in self.scaling_policies:
+                result['scalingPolicies'].append(k.to_map() if k else None)
+        result['scheduledPolicies'] = []
+        if self.scheduled_policies is not None:
+            for k in self.scheduled_policies:
+                result['scheduledPolicies'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('currentError') is not None:
+            self.current_error = m.get('currentError')
+        if m.get('currentInstances') is not None:
+            self.current_instances = m.get('currentInstances')
+        if m.get('functionArn') is not None:
+            self.function_arn = m.get('functionArn')
+        if m.get('minInstances') is not None:
+            self.min_instances = m.get('minInstances')
+        if m.get('residentPoolId') is not None:
+            self.resident_pool_id = m.get('residentPoolId')
+        self.scaling_policies = []
+        if m.get('scalingPolicies') is not None:
+            for k in m.get('scalingPolicies'):
+                temp_model = ScalingPolicy()
+                self.scaling_policies.append(temp_model.from_map(k))
+        self.scheduled_policies = []
+        if m.get('scheduledPolicies') is not None:
+            for k in m.get('scheduledPolicies'):
+                temp_model = ScheduledPolicy()
+                self.scheduled_policies.append(temp_model.from_map(k))
+        return self
+
+
+class Error(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        message: str = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.message = message
+        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.code is not None:
+            result['Code'] = self.code
+        if self.message is not None:
+            result['Message'] = self.message
+        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('Code') is not None:
+            self.code = m.get('Code')
+        if m.get('Message') is not None:
+            self.message = m.get('Message')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        return self
+
+
+class EventSinkConfig(TeaModel):
+    def __init__(
+        self,
+        delivery_option: DeliveryOption = None,
+    ):
+        self.delivery_option = delivery_option
+
+    def validate(self):
+        if self.delivery_option:
+            self.delivery_option.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.delivery_option is not None:
+            result['deliveryOption'] = self.delivery_option.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('deliveryOption') is not None:
+            temp_model = DeliveryOption()
+            self.delivery_option = temp_model.from_map(m['deliveryOption'])
+        return self
+
+
+class SourceDTSParameters(TeaModel):
+    def __init__(
+        self,
+        broker_url: str = None,
+        init_check_point: int = None,
+        password: str = None,
+        region_id: str = None,
+        sid: str = None,
+        task_id: str = None,
+        topic: str = None,
+        username: str = None,
+    ):
+        self.broker_url = broker_url
+        self.init_check_point = init_check_point
+        self.password = password
+        self.region_id = region_id
+        self.sid = sid
+        self.task_id = task_id
+        self.topic = topic
+        self.username = username
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.broker_url is not None:
+            result['BrokerUrl'] = self.broker_url
+        if self.init_check_point is not None:
+            result['InitCheckPoint'] = self.init_check_point
+        if self.password is not None:
+            result['Password'] = self.password
+        if self.region_id is not None:
+            result['RegionId'] = self.region_id
+        if self.sid is not None:
+            result['Sid'] = self.sid
+        if self.task_id is not None:
+            result['TaskId'] = self.task_id
+        if self.topic is not None:
+            result['Topic'] = self.topic
+        if self.username is not None:
+            result['Username'] = self.username
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('BrokerUrl') is not None:
+            self.broker_url = m.get('BrokerUrl')
+        if m.get('InitCheckPoint') is not None:
+            self.init_check_point = m.get('InitCheckPoint')
+        if m.get('Password') is not None:
+            self.password = m.get('Password')
+        if m.get('RegionId') is not None:
+            self.region_id = m.get('RegionId')
+        if m.get('Sid') is not None:
+            self.sid = m.get('Sid')
+        if m.get('TaskId') is not None:
+            self.task_id = m.get('TaskId')
+        if m.get('Topic') is not None:
+            self.topic = m.get('Topic')
+        if m.get('Username') is not None:
+            self.username = m.get('Username')
+        return self
+
+
+class SourceKafkaParameters(TeaModel):
+    def __init__(
+        self,
+        consumer_group: str = None,
+        instance_id: str = None,
+        network: str = None,
+        offset_reset: str = None,
+        region_id: str = None,
+        security_group_id: str = None,
+        topic: str = None,
+        v_switch_ids: str = None,
+        vpc_id: str = None,
+    ):
+        self.consumer_group = consumer_group
+        self.instance_id = instance_id
+        self.network = network
+        self.offset_reset = offset_reset
+        self.region_id = region_id
+        self.security_group_id = security_group_id
+        self.topic = topic
+        self.v_switch_ids = v_switch_ids
+        self.vpc_id = vpc_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.consumer_group is not None:
+            result['ConsumerGroup'] = self.consumer_group
+        if self.instance_id is not None:
+            result['InstanceId'] = self.instance_id
+        if self.network is not None:
+            result['Network'] = self.network
+        if self.offset_reset is not None:
+            result['OffsetReset'] = self.offset_reset
+        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.topic is not None:
+            result['Topic'] = self.topic
+        if self.v_switch_ids is not None:
+            result['VSwitchIds'] = self.v_switch_ids
+        if self.vpc_id is not None:
+            result['VpcId'] = self.vpc_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('ConsumerGroup') is not None:
+            self.consumer_group = m.get('ConsumerGroup')
+        if m.get('InstanceId') is not None:
+            self.instance_id = m.get('InstanceId')
+        if m.get('Network') is not None:
+            self.network = m.get('Network')
+        if m.get('OffsetReset') is not None:
+            self.offset_reset = m.get('OffsetReset')
+        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')
@@ -3238,7 +3694,7 @@ class Filter(TeaModel):
         return self
 
 
-class OpenStructFunctionRestriction(TeaModel):
+class FunctionRestriction(TeaModel):
     def __init__(
         self,
         disable: bool = None,
@@ -3323,6 +3779,7 @@ class Function(TeaModel):
         description: str = None,
         disable_ondemand: bool = None,
         disk_size: int = None,
+        enable_long_living: bool = None,
         environment_variables: Dict[str, str] = None,
         function_arn: str = None,
         function_id: str = None,
@@ -3330,9 +3787,10 @@ class Function(TeaModel):
         gpu_config: GPUConfig = None,
         handler: str = None,
         instance_concurrency: int = None,
+        instance_isolation_mode: str = None,
         instance_lifecycle_config: InstanceLifecycleConfig = None,
         internet_access: bool = None,
-        invocation_restriction: OpenStructFunctionRestriction = None,
+        invocation_restriction: FunctionRestriction = None,
         last_modified_time: str = None,
         last_update_status: str = None,
         last_update_status_reason: str = None,
@@ -3342,8 +3800,11 @@ class Function(TeaModel):
         memory_size: int = None,
         nas_config: NASConfig = None,
         oss_mount_config: OSSMountConfig = None,
+        resource_group_id: str = None,
         role: str = None,
         runtime: str = None,
+        session_affinity: str = None,
+        session_affinity_config: str = None,
         state: str = None,
         state_reason: str = None,
         state_reason_code: str = None,
@@ -3362,6 +3823,7 @@ class Function(TeaModel):
         self.description = description
         self.disable_ondemand = disable_ondemand
         self.disk_size = disk_size
+        self.enable_long_living = enable_long_living
         self.environment_variables = environment_variables
         self.function_arn = function_arn
         self.function_id = function_id
@@ -3369,6 +3831,7 @@ class Function(TeaModel):
         self.gpu_config = gpu_config
         self.handler = handler
         self.instance_concurrency = instance_concurrency
+        self.instance_isolation_mode = instance_isolation_mode
         self.instance_lifecycle_config = instance_lifecycle_config
         self.internet_access = internet_access
         self.invocation_restriction = invocation_restriction
@@ -3381,8 +3844,11 @@ class Function(TeaModel):
         self.memory_size = memory_size
         self.nas_config = nas_config
         self.oss_mount_config = oss_mount_config
+        self.resource_group_id = resource_group_id
         self.role = role
         self.runtime = runtime
+        self.session_affinity = session_affinity
+        self.session_affinity_config = session_affinity_config
         self.state = state
         self.state_reason = state_reason
         self.state_reason_code = state_reason_code
@@ -3449,6 +3915,8 @@ class Function(TeaModel):
             result['disableOndemand'] = self.disable_ondemand
         if self.disk_size is not None:
             result['diskSize'] = self.disk_size
+        if self.enable_long_living is not None:
+            result['enableLongLiving'] = self.enable_long_living
         if self.environment_variables is not None:
             result['environmentVariables'] = self.environment_variables
         if self.function_arn is not None:
@@ -3463,6 +3931,8 @@ class Function(TeaModel):
             result['handler'] = self.handler
         if self.instance_concurrency is not None:
             result['instanceConcurrency'] = self.instance_concurrency
+        if self.instance_isolation_mode is not None:
+            result['instanceIsolationMode'] = self.instance_isolation_mode
         if self.instance_lifecycle_config is not None:
             result['instanceLifecycleConfig'] = self.instance_lifecycle_config.to_map()
         if self.internet_access is not None:
@@ -3489,10 +3959,16 @@ class Function(TeaModel):
             result['nasConfig'] = self.nas_config.to_map()
         if self.oss_mount_config is not None:
             result['ossMountConfig'] = self.oss_mount_config.to_map()
+        if self.resource_group_id is not None:
+            result['resourceGroupId'] = self.resource_group_id
         if self.role is not None:
             result['role'] = self.role
         if self.runtime is not None:
             result['runtime'] = self.runtime
+        if self.session_affinity is not None:
+            result['sessionAffinity'] = self.session_affinity
+        if self.session_affinity_config is not None:
+            result['sessionAffinityConfig'] = self.session_affinity_config
         if self.state is not None:
             result['state'] = self.state
         if self.state_reason is not None:
@@ -3536,6 +4012,8 @@ class Function(TeaModel):
             self.disable_ondemand = m.get('disableOndemand')
         if m.get('diskSize') is not None:
             self.disk_size = m.get('diskSize')
+        if m.get('enableLongLiving') is not None:
+            self.enable_long_living = m.get('enableLongLiving')
         if m.get('environmentVariables') is not None:
             self.environment_variables = m.get('environmentVariables')
         if m.get('functionArn') is not None:
@@ -3551,13 +4029,15 @@ class Function(TeaModel):
             self.handler = m.get('handler')
         if m.get('instanceConcurrency') is not None:
             self.instance_concurrency = m.get('instanceConcurrency')
+        if m.get('instanceIsolationMode') is not None:
+            self.instance_isolation_mode = m.get('instanceIsolationMode')
         if m.get('instanceLifecycleConfig') is not None:
             temp_model = InstanceLifecycleConfig()
             self.instance_lifecycle_config = temp_model.from_map(m['instanceLifecycleConfig'])
         if m.get('internetAccess') is not None:
             self.internet_access = m.get('internetAccess')
         if m.get('invocationRestriction') is not None:
-            temp_model = OpenStructFunctionRestriction()
+            temp_model = FunctionRestriction()
             self.invocation_restriction = temp_model.from_map(m['invocationRestriction'])
         if m.get('lastModifiedTime') is not None:
             self.last_modified_time = m.get('lastModifiedTime')
@@ -3583,10 +4063,16 @@ class Function(TeaModel):
         if m.get('ossMountConfig') is not None:
             temp_model = OSSMountConfig()
             self.oss_mount_config = temp_model.from_map(m['ossMountConfig'])
+        if m.get('resourceGroupId') is not None:
+            self.resource_group_id = m.get('resourceGroupId')
         if m.get('role') is not None:
             self.role = m.get('role')
         if m.get('runtime') is not None:
             self.runtime = m.get('runtime')
+        if m.get('sessionAffinity') is not None:
+            self.session_affinity = m.get('sessionAffinity')
+        if m.get('sessionAffinityConfig') is not None:
+            self.session_affinity_config = m.get('sessionAffinityConfig')
         if m.get('state') is not None:
             self.state = m.get('state')
         if m.get('stateReason') is not None:
@@ -3699,29 +4185,187 @@ class GetInstanceLifecycleEventsOutput(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        self.events = []
-        if m.get('events') is not None:
-            for k in m.get('events'):
-                temp_model = InstanceEventItem()
-                self.events.append(temp_model.from_map(k))
-        if m.get('requestId') is not None:
-            self.request_id = m.get('requestId')
+        self.events = []
+        if m.get('events') is not None:
+            for k in m.get('events'):
+                temp_model = InstanceEventItem()
+                self.events.append(temp_model.from_map(k))
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class GetResourceTagsOutput(TeaModel):
+    def __init__(
+        self,
+        resouce_type: str = None,
+        resource_arn: str = None,
+        tags: Dict[str, str] = None,
+    ):
+        self.resouce_type = resouce_type
+        self.resource_arn = resource_arn
+        self.tags = tags
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.resouce_type is not None:
+            result['resouceType'] = self.resouce_type
+        if self.resource_arn is not None:
+            result['resourceArn'] = self.resource_arn
+        if self.tags is not None:
+            result['tags'] = self.tags
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('resouceType') is not None:
+            self.resouce_type = m.get('resouceType')
+        if m.get('resourceArn') is not None:
+            self.resource_arn = m.get('resourceArn')
+        if m.get('tags') is not None:
+            self.tags = m.get('tags')
+        return self
+
+
+class ResidentConfig(TeaModel):
+    def __init__(
+        self,
+        count: int = None,
+        pool_id: str = None,
+    ):
+        self.count = count
+        self.pool_id = pool_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.count is not None:
+            result['count'] = self.count
+        if self.pool_id is not None:
+            result['poolId'] = self.pool_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('count') is not None:
+            self.count = m.get('count')
+        if m.get('poolId') is not None:
+            self.pool_id = m.get('poolId')
+        return self
+
+
+class ScalingStatus(TeaModel):
+    def __init__(
+        self,
+        current_error: str = None,
+        resource_count: int = None,
+    ):
+        self.current_error = current_error
+        self.resource_count = resource_count
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.current_error is not None:
+            result['currentError'] = self.current_error
+        if self.resource_count is not None:
+            result['resourceCount'] = self.resource_count
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('currentError') is not None:
+            self.current_error = m.get('currentError')
+        if m.get('resourceCount') is not None:
+            self.resource_count = m.get('resourceCount')
+        return self
+
+
+class ScalingConfigStatus(TeaModel):
+    def __init__(
+        self,
+        function_name: str = None,
+        qualifier: str = None,
+        resident_config: ResidentConfig = None,
+        resource_type: str = None,
+        scaling_status: ScalingStatus = None,
+    ):
+        self.function_name = function_name
+        self.qualifier = qualifier
+        self.resident_config = resident_config
+        self.resource_type = resource_type
+        self.scaling_status = scaling_status
+
+    def validate(self):
+        if self.resident_config:
+            self.resident_config.validate()
+        if self.scaling_status:
+            self.scaling_status.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.function_name is not None:
+            result['functionName'] = self.function_name
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        if self.resident_config is not None:
+            result['residentConfig'] = self.resident_config.to_map()
+        if self.resource_type is not None:
+            result['resourceType'] = self.resource_type
+        if self.scaling_status is not None:
+            result['scalingStatus'] = self.scaling_status.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('functionName') is not None:
+            self.function_name = m.get('functionName')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        if m.get('residentConfig') is not None:
+            temp_model = ResidentConfig()
+            self.resident_config = temp_model.from_map(m['residentConfig'])
+        if m.get('resourceType') is not None:
+            self.resource_type = m.get('resourceType')
+        if m.get('scalingStatus') is not None:
+            temp_model = ScalingStatus()
+            self.scaling_status = temp_model.from_map(m['scalingStatus'])
         return self
 
 
-class GetResourceTagsOutput(TeaModel):
+class GetScalingConfigStatusOutput(TeaModel):
     def __init__(
         self,
-        resouce_type: str = None,
-        resource_arn: str = None,
-        tags: Dict[str, str] = None,
+        scaling_config_status: ScalingConfigStatus = None,
     ):
-        self.resouce_type = resouce_type
-        self.resource_arn = resource_arn
-        self.tags = tags
+        self.scaling_config_status = scaling_config_status
 
     def validate(self):
-        pass
+        if self.scaling_config_status:
+            self.scaling_config_status.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -3729,22 +4373,15 @@ class GetResourceTagsOutput(TeaModel):
             return _map
 
         result = dict()
-        if self.resouce_type is not None:
-            result['resouceType'] = self.resouce_type
-        if self.resource_arn is not None:
-            result['resourceArn'] = self.resource_arn
-        if self.tags is not None:
-            result['tags'] = self.tags
+        if self.scaling_config_status is not None:
+            result['scalingConfigStatus'] = self.scaling_config_status.to_map()
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('resouceType') is not None:
-            self.resouce_type = m.get('resouceType')
-        if m.get('resourceArn') is not None:
-            self.resource_arn = m.get('resourceArn')
-        if m.get('tags') is not None:
-            self.tags = m.get('tags')
+        if m.get('scalingConfigStatus') is not None:
+            temp_model = ScalingConfigStatus()
+            self.scaling_config_status = temp_model.from_map(m['scalingConfigStatus'])
         return self
 
 
@@ -3826,6 +4463,51 @@ class HTTPTriggerConfig(TeaModel):
         return self
 
 
+class HeaderFieldSessionAffinityConfig(TeaModel):
+    def __init__(
+        self,
+        affinity_header_field_name: str = None,
+        session_concurrency_per_instance: int = None,
+        session_idle_timeout_in_seconds: int = None,
+        session_ttlin_seconds: int = None,
+    ):
+        self.affinity_header_field_name = affinity_header_field_name
+        self.session_concurrency_per_instance = session_concurrency_per_instance
+        self.session_idle_timeout_in_seconds = session_idle_timeout_in_seconds
+        self.session_ttlin_seconds = session_ttlin_seconds
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.affinity_header_field_name is not None:
+            result['affinityHeaderFieldName'] = self.affinity_header_field_name
+        if self.session_concurrency_per_instance is not None:
+            result['sessionConcurrencyPerInstance'] = self.session_concurrency_per_instance
+        if self.session_idle_timeout_in_seconds is not None:
+            result['sessionIdleTimeoutInSeconds'] = self.session_idle_timeout_in_seconds
+        if self.session_ttlin_seconds is not None:
+            result['sessionTTLInSeconds'] = self.session_ttlin_seconds
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('affinityHeaderFieldName') is not None:
+            self.affinity_header_field_name = m.get('affinityHeaderFieldName')
+        if m.get('sessionConcurrencyPerInstance') is not None:
+            self.session_concurrency_per_instance = m.get('sessionConcurrencyPerInstance')
+        if m.get('sessionIdleTimeoutInSeconds') is not None:
+            self.session_idle_timeout_in_seconds = m.get('sessionIdleTimeoutInSeconds')
+        if m.get('sessionTTLInSeconds') is not None:
+            self.session_ttlin_seconds = m.get('sessionTTLInSeconds')
+        return self
+
+
 class InstanceInfo(TeaModel):
     def __init__(
         self,
@@ -4244,6 +4926,47 @@ class ListCustomDomainOutput(TeaModel):
         return self
 
 
+class ListElasticConfigsOutput(TeaModel):
+    def __init__(
+        self,
+        elastic_configs: List[ElasticConfigStatus] = None,
+        next_token: str = None,
+    ):
+        self.elastic_configs = elastic_configs
+        self.next_token = next_token
+
+    def validate(self):
+        if self.elastic_configs:
+            for k in self.elastic_configs:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        result['elasticConfigs'] = []
+        if self.elastic_configs is not None:
+            for k in self.elastic_configs:
+                result['elasticConfigs'].append(k.to_map() if k else None)
+        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()
+        self.elastic_configs = []
+        if m.get('elasticConfigs') is not None:
+            for k in m.get('elasticConfigs'):
+                temp_model = ElasticConfigStatus()
+                self.elastic_configs.append(temp_model.from_map(k))
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        return self
+
+
 class ListFunctionsOutput(TeaModel):
     def __init__(
         self,
@@ -4634,18 +5357,353 @@ class ProvisionConfig(TeaModel):
         return self
 
 
-class ListProvisionConfigsOutput(TeaModel):
+class ListProvisionConfigsOutput(TeaModel):
+    def __init__(
+        self,
+        next_token: str = None,
+        provision_configs: List[ProvisionConfig] = None,
+    ):
+        self.next_token = next_token
+        self.provision_configs = provision_configs
+
+    def validate(self):
+        if self.provision_configs:
+            for k in self.provision_configs:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        result['provisionConfigs'] = []
+        if self.provision_configs is not None:
+            for k in self.provision_configs:
+                result['provisionConfigs'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        self.provision_configs = []
+        if m.get('provisionConfigs') is not None:
+            for k in m.get('provisionConfigs'):
+                temp_model = ProvisionConfig()
+                self.provision_configs.append(temp_model.from_map(k))
+        return self
+
+
+class ResidentResourceAllocation(TeaModel):
+    def __init__(
+        self,
+        function_name: str = None,
+        instance_count: int = None,
+        qualifier: str = None,
+        total_cpu_cores: float = None,
+        total_disk_size: float = None,
+        total_gpu_memory_size: float = None,
+        total_memory_size: float = None,
+    ):
+        # 使用该资源池的函数名
+        self.function_name = function_name
+        # 实例数
+        self.instance_count = instance_count
+        # 函数的别名
+        self.qualifier = qualifier
+        # CPU 占用总核数
+        self.total_cpu_cores = total_cpu_cores
+        # 占用磁盘大小，单位 GB
+        self.total_disk_size = total_disk_size
+        # 占用显存大小，单位 GB
+        self.total_gpu_memory_size = total_gpu_memory_size
+        # 内存占用大小，单位 GB
+        self.total_memory_size = total_memory_size
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.function_name is not None:
+            result['functionName'] = self.function_name
+        if self.instance_count is not None:
+            result['instanceCount'] = self.instance_count
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        if self.total_cpu_cores is not None:
+            result['totalCpuCores'] = self.total_cpu_cores
+        if self.total_disk_size is not None:
+            result['totalDiskSize'] = self.total_disk_size
+        if self.total_gpu_memory_size is not None:
+            result['totalGpuMemorySize'] = self.total_gpu_memory_size
+        if self.total_memory_size is not None:
+            result['totalMemorySize'] = self.total_memory_size
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('functionName') is not None:
+            self.function_name = m.get('functionName')
+        if m.get('instanceCount') is not None:
+            self.instance_count = m.get('instanceCount')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        if m.get('totalCpuCores') is not None:
+            self.total_cpu_cores = m.get('totalCpuCores')
+        if m.get('totalDiskSize') is not None:
+            self.total_disk_size = m.get('totalDiskSize')
+        if m.get('totalGpuMemorySize') is not None:
+            self.total_gpu_memory_size = m.get('totalGpuMemorySize')
+        if m.get('totalMemorySize') is not None:
+            self.total_memory_size = m.get('totalMemorySize')
+        return self
+
+
+class ResidentResourceAllocationStatus(TeaModel):
+    def __init__(
+        self,
+        last_allocated_time: str = None,
+        last_allocation: ResidentResourceAllocation = None,
+    ):
+        self.last_allocated_time = last_allocated_time
+        self.last_allocation = last_allocation
+
+    def validate(self):
+        if self.last_allocation:
+            self.last_allocation.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.last_allocated_time is not None:
+            result['lastAllocatedTime'] = self.last_allocated_time
+        if self.last_allocation is not None:
+            result['lastAllocation'] = self.last_allocation.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('lastAllocatedTime') is not None:
+            self.last_allocated_time = m.get('lastAllocatedTime')
+        if m.get('lastAllocation') is not None:
+            temp_model = ResidentResourceAllocation()
+            self.last_allocation = temp_model.from_map(m['lastAllocation'])
+        return self
+
+
+class ResidentResourceCapacity(TeaModel):
+    def __init__(
+        self,
+        gpu_type: str = None,
+        total_cpu_cores: int = None,
+        total_disk_size: int = None,
+        total_gpu_cards: int = None,
+        total_gpu_memory_size: int = None,
+        total_memory_size: int = None,
+    ):
+        # GPU 卡型
+        self.gpu_type = gpu_type
+        # CPU 总核数
+        self.total_cpu_cores = total_cpu_cores
+        # 总磁盘大小，单位 GB
+        self.total_disk_size = total_disk_size
+        # GPU总卡数
+        self.total_gpu_cards = total_gpu_cards
+        # 总显存大小，单位 GB
+        self.total_gpu_memory_size = total_gpu_memory_size
+        # 总内存大小，单位 GB
+        self.total_memory_size = total_memory_size
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.gpu_type is not None:
+            result['gpuType'] = self.gpu_type
+        if self.total_cpu_cores is not None:
+            result['totalCpuCores'] = self.total_cpu_cores
+        if self.total_disk_size is not None:
+            result['totalDiskSize'] = self.total_disk_size
+        if self.total_gpu_cards is not None:
+            result['totalGpuCards'] = self.total_gpu_cards
+        if self.total_gpu_memory_size is not None:
+            result['totalGpuMemorySize'] = self.total_gpu_memory_size
+        if self.total_memory_size is not None:
+            result['totalMemorySize'] = self.total_memory_size
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('gpuType') is not None:
+            self.gpu_type = m.get('gpuType')
+        if m.get('totalCpuCores') is not None:
+            self.total_cpu_cores = m.get('totalCpuCores')
+        if m.get('totalDiskSize') is not None:
+            self.total_disk_size = m.get('totalDiskSize')
+        if m.get('totalGpuCards') is not None:
+            self.total_gpu_cards = m.get('totalGpuCards')
+        if m.get('totalGpuMemorySize') is not None:
+            self.total_gpu_memory_size = m.get('totalGpuMemorySize')
+        if m.get('totalMemorySize') is not None:
+            self.total_memory_size = m.get('totalMemorySize')
+        return self
+
+
+class ResidentResourcePool(TeaModel):
+    def __init__(
+        self,
+        allocation_status: ResidentResourceAllocationStatus = None,
+        created_time: str = None,
+        expire_time: str = None,
+        last_modified_time: str = None,
+        resident_resource_pool_id: str = None,
+        resident_resource_pool_name: str = None,
+        resource_pool_capacity: ResidentResourceCapacity = None,
+        resource_pool_config: ResidentResourceCapacity = None,
+    ):
+        # 资源池实时分配情况，包含每个函数的具体分配情况
+        self.allocation_status = allocation_status
+        # 代表创建时间的资源属性字段
+        # 
+        # Use the UTC time format: yyyy-MM-ddTHH:mmZ
+        self.created_time = created_time
+        # 资源池过期时间
+        self.expire_time = expire_time
+        # 上次修改时间，包含扩容、续费、更名等操作
+        self.last_modified_time = last_modified_time
+        self.resident_resource_pool_id = resident_resource_pool_id
+        # 代表资源名称的资源属性字段
+        self.resident_resource_pool_name = resident_resource_pool_name
+        # 资源池总体规格
+        self.resource_pool_capacity = resource_pool_capacity
+        self.resource_pool_config = resource_pool_config
+
+    def validate(self):
+        if self.allocation_status:
+            self.allocation_status.validate()
+        if self.resource_pool_capacity:
+            self.resource_pool_capacity.validate()
+        if self.resource_pool_config:
+            self.resource_pool_config.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.allocation_status is not None:
+            result['allocationStatus'] = self.allocation_status.to_map()
+        if self.created_time is not None:
+            result['createdTime'] = self.created_time
+        if self.expire_time is not None:
+            result['expireTime'] = self.expire_time
+        if self.last_modified_time is not None:
+            result['lastModifiedTime'] = self.last_modified_time
+        if self.resident_resource_pool_id is not None:
+            result['residentResourcePoolId'] = self.resident_resource_pool_id
+        if self.resident_resource_pool_name is not None:
+            result['residentResourcePoolName'] = self.resident_resource_pool_name
+        if self.resource_pool_capacity is not None:
+            result['resourcePoolCapacity'] = self.resource_pool_capacity.to_map()
+        if self.resource_pool_config is not None:
+            result['resourcePoolConfig'] = self.resource_pool_config.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('allocationStatus') is not None:
+            temp_model = ResidentResourceAllocationStatus()
+            self.allocation_status = temp_model.from_map(m['allocationStatus'])
+        if m.get('createdTime') is not None:
+            self.created_time = m.get('createdTime')
+        if m.get('expireTime') is not None:
+            self.expire_time = m.get('expireTime')
+        if m.get('lastModifiedTime') is not None:
+            self.last_modified_time = m.get('lastModifiedTime')
+        if m.get('residentResourcePoolId') is not None:
+            self.resident_resource_pool_id = m.get('residentResourcePoolId')
+        if m.get('residentResourcePoolName') is not None:
+            self.resident_resource_pool_name = m.get('residentResourcePoolName')
+        if m.get('resourcePoolCapacity') is not None:
+            temp_model = ResidentResourceCapacity()
+            self.resource_pool_capacity = temp_model.from_map(m['resourcePoolCapacity'])
+        if m.get('resourcePoolConfig') is not None:
+            temp_model = ResidentResourceCapacity()
+            self.resource_pool_config = temp_model.from_map(m['resourcePoolConfig'])
+        return self
+
+
+class ListResidentResourcePoolsOutput(TeaModel):
+    def __init__(
+        self,
+        next_token: str = None,
+        resident_resource_pools: List[ResidentResourcePool] = None,
+    ):
+        self.next_token = next_token
+        self.resident_resource_pools = resident_resource_pools
+
+    def validate(self):
+        if self.resident_resource_pools:
+            for k in self.resident_resource_pools:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        result['residentResourcePools'] = []
+        if self.resident_resource_pools is not None:
+            for k in self.resident_resource_pools:
+                result['residentResourcePools'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        self.resident_resource_pools = []
+        if m.get('residentResourcePools') is not None:
+            for k in m.get('residentResourcePools'):
+                temp_model = ResidentResourcePool()
+                self.resident_resource_pools.append(temp_model.from_map(k))
+        return self
+
+
+class ListScalingConfigStatusOutput(TeaModel):
     def __init__(
         self,
         next_token: str = None,
-        provision_configs: List[ProvisionConfig] = None,
+        result: List[ScalingConfigStatus] = None,
     ):
         self.next_token = next_token
-        self.provision_configs = provision_configs
+        self.result = result
 
     def validate(self):
-        if self.provision_configs:
-            for k in self.provision_configs:
+        if self.result:
+            for k in self.result:
                 if k:
                     k.validate()
 
@@ -4657,21 +5715,21 @@ class ListProvisionConfigsOutput(TeaModel):
         result = dict()
         if self.next_token is not None:
             result['nextToken'] = self.next_token
-        result['provisionConfigs'] = []
-        if self.provision_configs is not None:
-            for k in self.provision_configs:
-                result['provisionConfigs'].append(k.to_map() if k else None)
+        result['result'] = []
+        if self.result is not None:
+            for k in self.result:
+                result['result'].append(k.to_map() if k else None)
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('nextToken') is not None:
             self.next_token = m.get('nextToken')
-        self.provision_configs = []
-        if m.get('provisionConfigs') is not None:
-            for k in m.get('provisionConfigs'):
-                temp_model = ProvisionConfig()
-                self.provision_configs.append(temp_model.from_map(k))
+        self.result = []
+        if m.get('result') is not None:
+            for k in m.get('result'):
+                temp_model = ScalingConfigStatus()
+                self.result.append(temp_model.from_map(k))
         return self
 
 
@@ -5108,6 +6166,78 @@ class ListVpcBindingsOutput(TeaModel):
         return self
 
 
+class MCPSSESessionAffinityConfig(TeaModel):
+    def __init__(
+        self,
+        session_concurrency_per_instance: int = None,
+        sse_endpoint_path: str = None,
+    ):
+        self.session_concurrency_per_instance = session_concurrency_per_instance
+        self.sse_endpoint_path = sse_endpoint_path
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.session_concurrency_per_instance is not None:
+            result['sessionConcurrencyPerInstance'] = self.session_concurrency_per_instance
+        if self.sse_endpoint_path is not None:
+            result['sseEndpointPath'] = self.sse_endpoint_path
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('sessionConcurrencyPerInstance') is not None:
+            self.session_concurrency_per_instance = m.get('sessionConcurrencyPerInstance')
+        if m.get('sseEndpointPath') is not None:
+            self.sse_endpoint_path = m.get('sseEndpointPath')
+        return self
+
+
+class MCPStreamableSessionAffinityConfig(TeaModel):
+    def __init__(
+        self,
+        session_concurrency_per_instance: int = None,
+        session_idle_timeout_in_seconds: int = None,
+        session_ttlin_seconds: int = None,
+    ):
+        self.session_concurrency_per_instance = session_concurrency_per_instance
+        self.session_idle_timeout_in_seconds = session_idle_timeout_in_seconds
+        self.session_ttlin_seconds = session_ttlin_seconds
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.session_concurrency_per_instance is not None:
+            result['sessionConcurrencyPerInstance'] = self.session_concurrency_per_instance
+        if self.session_idle_timeout_in_seconds is not None:
+            result['sessionIdleTimeoutInSeconds'] = self.session_idle_timeout_in_seconds
+        if self.session_ttlin_seconds is not None:
+            result['sessionTTLInSeconds'] = self.session_ttlin_seconds
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('sessionConcurrencyPerInstance') is not None:
+            self.session_concurrency_per_instance = m.get('sessionConcurrencyPerInstance')
+        if m.get('sessionIdleTimeoutInSeconds') is not None:
+            self.session_idle_timeout_in_seconds = m.get('sessionIdleTimeoutInSeconds')
+        if m.get('sessionTTLInSeconds') is not None:
+            self.session_ttlin_seconds = m.get('sessionTTLInSeconds')
+        return self
+
+
 class MNSTopicTriggerConfig(TeaModel):
     def __init__(
         self,
@@ -5317,6 +6447,68 @@ class PutConcurrencyInput(TeaModel):
         return self
 
 
+class PutElasticConfigInput(TeaModel):
+    def __init__(
+        self,
+        min_instances: int = None,
+        resident_pool_id: str = None,
+        scaling_policies: List[ScalingPolicy] = None,
+        scheduled_policies: List[ScheduledPolicy] = None,
+    ):
+        self.min_instances = min_instances
+        self.resident_pool_id = resident_pool_id
+        self.scaling_policies = scaling_policies
+        self.scheduled_policies = scheduled_policies
+
+    def validate(self):
+        if self.scaling_policies:
+            for k in self.scaling_policies:
+                if k:
+                    k.validate()
+        if self.scheduled_policies:
+            for k in self.scheduled_policies:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.min_instances is not None:
+            result['minInstances'] = self.min_instances
+        if self.resident_pool_id is not None:
+            result['residentPoolId'] = self.resident_pool_id
+        result['scalingPolicies'] = []
+        if self.scaling_policies is not None:
+            for k in self.scaling_policies:
+                result['scalingPolicies'].append(k.to_map() if k else None)
+        result['scheduledPolicies'] = []
+        if self.scheduled_policies is not None:
+            for k in self.scheduled_policies:
+                result['scheduledPolicies'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('minInstances') is not None:
+            self.min_instances = m.get('minInstances')
+        if m.get('residentPoolId') is not None:
+            self.resident_pool_id = m.get('residentPoolId')
+        self.scaling_policies = []
+        if m.get('scalingPolicies') is not None:
+            for k in m.get('scalingPolicies'):
+                temp_model = ScalingPolicy()
+                self.scaling_policies.append(temp_model.from_map(k))
+        self.scheduled_policies = []
+        if m.get('scheduledPolicies') is not None:
+            for k in m.get('scheduledPolicies'):
+                temp_model = ScheduledPolicy()
+                self.scheduled_policies.append(temp_model.from_map(k))
+        return self
+
+
 class PutProvisionConfigInput(TeaModel):
     def __init__(
         self,
@@ -5392,6 +6584,88 @@ class PutProvisionConfigInput(TeaModel):
         return self
 
 
+class PutScalingConfigInput(TeaModel):
+    def __init__(
+        self,
+        resident_config: ResidentConfig = None,
+        resource_type: str = None,
+    ):
+        self.resident_config = resident_config
+        self.resource_type = resource_type
+
+    def validate(self):
+        if self.resident_config:
+            self.resident_config.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.resident_config is not None:
+            result['residentConfig'] = self.resident_config.to_map()
+        if self.resource_type is not None:
+            result['resourceType'] = self.resource_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('residentConfig') is not None:
+            temp_model = ResidentConfig()
+            self.resident_config = temp_model.from_map(m['residentConfig'])
+        if m.get('resourceType') is not None:
+            self.resource_type = m.get('resourceType')
+        return self
+
+
+class PutScalingConfigOutput(TeaModel):
+    def __init__(
+        self,
+        function_name: str = None,
+        qualifier: str = None,
+        resident_config: ResidentConfig = None,
+        resource_type: str = None,
+    ):
+        self.function_name = function_name
+        self.qualifier = qualifier
+        self.resident_config = resident_config
+        self.resource_type = resource_type
+
+    def validate(self):
+        if self.resident_config:
+            self.resident_config.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.function_name is not None:
+            result['functionName'] = self.function_name
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        if self.resident_config is not None:
+            result['residentConfig'] = self.resident_config.to_map()
+        if self.resource_type is not None:
+            result['resourceType'] = self.resource_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('functionName') is not None:
+            self.function_name = m.get('functionName')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        if m.get('residentConfig') is not None:
+            temp_model = ResidentConfig()
+            self.resident_config = temp_model.from_map(m['residentConfig'])
+        if m.get('resourceType') is not None:
+            self.resource_type = m.get('resourceType')
+        return self
+
+
 class SLSTriggerLogConfig(TeaModel):
     def __init__(
         self,
@@ -5761,10 +7035,12 @@ class UpdateFunctionInput(TeaModel):
         description: str = None,
         disable_ondemand: bool = None,
         disk_size: int = None,
+        enable_long_living: bool = None,
         environment_variables: Dict[str, str] = None,
         gpu_config: GPUConfig = None,
         handler: str = None,
         instance_concurrency: int = None,
+        instance_isolation_mode: str = None,
         instance_lifecycle_config: InstanceLifecycleConfig = None,
         internet_access: bool = None,
         layers: List[str] = None,
@@ -5774,6 +7050,8 @@ class UpdateFunctionInput(TeaModel):
         oss_mount_config: OSSMountConfig = None,
         role: str = None,
         runtime: str = None,
+        session_affinity: str = None,
+        session_affinity_config: str = None,
         timeout: int = None,
         tracing_config: TracingConfig = None,
         vpc_config: VPCConfig = None,
@@ -5786,10 +7064,12 @@ class UpdateFunctionInput(TeaModel):
         self.description = description
         self.disable_ondemand = disable_ondemand
         self.disk_size = disk_size
+        self.enable_long_living = enable_long_living
         self.environment_variables = environment_variables
         self.gpu_config = gpu_config
         self.handler = handler
         self.instance_concurrency = instance_concurrency
+        self.instance_isolation_mode = instance_isolation_mode
         self.instance_lifecycle_config = instance_lifecycle_config
         self.internet_access = internet_access
         self.layers = layers
@@ -5799,6 +7079,8 @@ class UpdateFunctionInput(TeaModel):
         self.oss_mount_config = oss_mount_config
         self.role = role
         self.runtime = runtime
+        self.session_affinity = session_affinity
+        self.session_affinity_config = session_affinity_config
         self.timeout = timeout
         self.tracing_config = tracing_config
         self.vpc_config = vpc_config
@@ -5849,6 +7131,8 @@ class UpdateFunctionInput(TeaModel):
             result['disableOndemand'] = self.disable_ondemand
         if self.disk_size is not None:
             result['diskSize'] = self.disk_size
+        if self.enable_long_living is not None:
+            result['enableLongLiving'] = self.enable_long_living
         if self.environment_variables is not None:
             result['environmentVariables'] = self.environment_variables
         if self.gpu_config is not None:
@@ -5857,6 +7141,8 @@ class UpdateFunctionInput(TeaModel):
             result['handler'] = self.handler
         if self.instance_concurrency is not None:
             result['instanceConcurrency'] = self.instance_concurrency
+        if self.instance_isolation_mode is not None:
+            result['instanceIsolationMode'] = self.instance_isolation_mode
         if self.instance_lifecycle_config is not None:
             result['instanceLifecycleConfig'] = self.instance_lifecycle_config.to_map()
         if self.internet_access is not None:
@@ -5875,6 +7161,10 @@ class UpdateFunctionInput(TeaModel):
             result['role'] = self.role
         if self.runtime is not None:
             result['runtime'] = self.runtime
+        if self.session_affinity is not None:
+            result['sessionAffinity'] = self.session_affinity
+        if self.session_affinity_config is not None:
+            result['sessionAffinityConfig'] = self.session_affinity_config
         if self.timeout is not None:
             result['timeout'] = self.timeout
         if self.tracing_config is not None:
@@ -5905,6 +7195,8 @@ class UpdateFunctionInput(TeaModel):
             self.disable_ondemand = m.get('disableOndemand')
         if m.get('diskSize') is not None:
             self.disk_size = m.get('diskSize')
+        if m.get('enableLongLiving') is not None:
+            self.enable_long_living = m.get('enableLongLiving')
         if m.get('environmentVariables') is not None:
             self.environment_variables = m.get('environmentVariables')
         if m.get('gpuConfig') is not None:
@@ -5914,6 +7206,8 @@ class UpdateFunctionInput(TeaModel):
             self.handler = m.get('handler')
         if m.get('instanceConcurrency') is not None:
             self.instance_concurrency = m.get('instanceConcurrency')
+        if m.get('instanceIsolationMode') is not None:
+            self.instance_isolation_mode = m.get('instanceIsolationMode')
         if m.get('instanceLifecycleConfig') is not None:
             temp_model = InstanceLifecycleConfig()
             self.instance_lifecycle_config = temp_model.from_map(m['instanceLifecycleConfig'])
@@ -5936,6 +7230,10 @@ class UpdateFunctionInput(TeaModel):
             self.role = m.get('role')
         if m.get('runtime') is not None:
             self.runtime = m.get('runtime')
+        if m.get('sessionAffinity') is not None:
+            self.session_affinity = m.get('sessionAffinity')
+        if m.get('sessionAffinityConfig') is not None:
+            self.session_affinity_config = m.get('sessionAffinityConfig')
         if m.get('timeout') is not None:
             self.timeout = m.get('timeout')
         if m.get('tracingConfig') is not None:
@@ -5947,6 +7245,33 @@ class UpdateFunctionInput(TeaModel):
         return self
 
 
+class UpdateResidentResourcePoolInput(TeaModel):
+    def __init__(
+        self,
+        name: str = None,
+    ):
+        self.name = name
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.name is not None:
+            result['name'] = self.name
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        return self
+
+
 class UpdateTriggerInput(TeaModel):
     def __init__(
         self,
@@ -5992,51 +7317,16 @@ class UpdateTriggerInput(TeaModel):
         return self
 
 
-class OpenStructDescribeRegionsOutputRegionsRegion(TeaModel):
-    def __init__(
-        self,
-        local_name: str = None,
-        region_id: str = None,
-    ):
-        self.local_name = local_name
-        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.local_name is not None:
-            result['LocalName'] = self.local_name
-        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('LocalName') is not None:
-            self.local_name = m.get('LocalName')
-        if m.get('RegionId') is not None:
-            self.region_id = m.get('RegionId')
-        return self
-
-
-class OpenStructDescribeRegionsOutputRegions(TeaModel):
+class ChangeResourceGroupRequest(TeaModel):
     def __init__(
         self,
-        region: List[OpenStructDescribeRegionsOutputRegionsRegion] = None,
+        body: ChangeResourceGroupInput = None,
     ):
-        self.region = region
+        self.body = body
 
     def validate(self):
-        if self.region:
-            for k in self.region:
-                if k:
-                    k.validate()
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -6044,32 +7334,32 @@ class OpenStructDescribeRegionsOutputRegions(TeaModel):
             return _map
 
         result = dict()
-        result['Region'] = []
-        if self.region is not None:
-            for k in self.region:
-                result['Region'].append(k.to_map() if k else None)
+        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()
-        self.region = []
-        if m.get('Region') is not None:
-            for k in m.get('Region'):
-                temp_model = OpenStructDescribeRegionsOutputRegionsRegion()
-                self.region.append(temp_model.from_map(k))
+        if m.get('body') is not None:
+            temp_model = ChangeResourceGroupInput()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class OpenStructDescribeRegionsOutput(TeaModel):
+class ChangeResourceGroupResponse(TeaModel):
     def __init__(
         self,
-        regions: OpenStructDescribeRegionsOutputRegions = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ChangeResourceGroupOutput = None,
     ):
-        self.regions = regions
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        if self.regions:
-            self.regions.validate()
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -6077,15 +7367,23 @@ class OpenStructDescribeRegionsOutput(TeaModel):
             return _map
 
         result = dict()
-        if self.regions is not None:
-            result['Regions'] = self.regions.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('Regions') is not None:
-            temp_model = OpenStructDescribeRegionsOutputRegions()
-            self.regions = temp_model.from_map(m['Regions'])
+        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 = ChangeResourceGroupOutput()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
@@ -6937,7 +8235,7 @@ class DescribeRegionsResponse(TeaModel):
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: OpenStructDescribeRegionsOutput = None,
+        body: DescribeRegionsOutput = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -6968,7 +8266,7 @@ class DescribeRegionsResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = OpenStructDescribeRegionsOutput()
+            temp_model = DescribeRegionsOutput()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -8424,10 +9722,12 @@ class ListFunctionsRequest(TeaModel):
         self,
         description: str = None,
         fc_version: str = None,
+        function_name: str = None,
         gpu_type: str = None,
         limit: int = None,
         next_token: str = None,
         prefix: str = None,
+        resource_group_id: str = None,
         runtime: str = None,
         tags: List[Tag] = None,
     ):
@@ -8440,6 +9740,7 @@ class ListFunctionsRequest(TeaModel):
         # 
         # By default, this parameter is left empty and functions in both Function Compute 3.0 and Function Compute 2.0 are listed.
         self.fc_version = fc_version
+        self.function_name = function_name
         # The GPU type of the functions to retrieve.
         self.gpu_type = gpu_type
         # The number of functions to return. The minimum value is 1 and the maximum value is 100.
@@ -8448,6 +9749,7 @@ class ListFunctionsRequest(TeaModel):
         self.next_token = next_token
         # The prefix of the function name.
         self.prefix = prefix
+        self.resource_group_id = resource_group_id
         # The runtime of the functions to retrieve.
         self.runtime = runtime
         # The tag of the functions to retrieve.
@@ -8469,6 +9771,8 @@ class ListFunctionsRequest(TeaModel):
             result['description'] = self.description
         if self.fc_version is not None:
             result['fcVersion'] = self.fc_version
+        if self.function_name is not None:
+            result['functionName'] = self.function_name
         if self.gpu_type is not None:
             result['gpuType'] = self.gpu_type
         if self.limit is not None:
@@ -8477,6 +9781,8 @@ class ListFunctionsRequest(TeaModel):
             result['nextToken'] = self.next_token
         if self.prefix is not None:
             result['prefix'] = self.prefix
+        if self.resource_group_id is not None:
+            result['resourceGroupId'] = self.resource_group_id
         if self.runtime is not None:
             result['runtime'] = self.runtime
         result['tags'] = []
@@ -8491,6 +9797,8 @@ class ListFunctionsRequest(TeaModel):
             self.description = m.get('description')
         if m.get('fcVersion') is not None:
             self.fc_version = m.get('fcVersion')
+        if m.get('functionName') is not None:
+            self.function_name = m.get('functionName')
         if m.get('gpuType') is not None:
             self.gpu_type = m.get('gpuType')
         if m.get('limit') is not None:
@@ -8499,6 +9807,8 @@ class ListFunctionsRequest(TeaModel):
             self.next_token = m.get('nextToken')
         if m.get('prefix') is not None:
             self.prefix = m.get('prefix')
+        if m.get('resourceGroupId') is not None:
+            self.resource_group_id = m.get('resourceGroupId')
         if m.get('runtime') is not None:
             self.runtime = m.get('runtime')
         self.tags = []
@@ -8514,10 +9824,12 @@ class ListFunctionsShrinkRequest(TeaModel):
         self,
         description: str = None,
         fc_version: str = None,
+        function_name: str = None,
         gpu_type: str = None,
         limit: int = None,
         next_token: str = None,
         prefix: str = None,
+        resource_group_id: str = None,
         runtime: str = None,
         tags_shrink: str = None,
     ):
@@ -8530,6 +9842,7 @@ class ListFunctionsShrinkRequest(TeaModel):
         # 
         # By default, this parameter is left empty and functions in both Function Compute 3.0 and Function Compute 2.0 are listed.
         self.fc_version = fc_version
+        self.function_name = function_name
         # The GPU type of the functions to retrieve.
         self.gpu_type = gpu_type
         # The number of functions to return. The minimum value is 1 and the maximum value is 100.
@@ -8538,6 +9851,7 @@ class ListFunctionsShrinkRequest(TeaModel):
         self.next_token = next_token
         # The prefix of the function name.
         self.prefix = prefix
+        self.resource_group_id = resource_group_id
         # The runtime of the functions to retrieve.
         self.runtime = runtime
         # The tag of the functions to retrieve.
@@ -8556,6 +9870,8 @@ class ListFunctionsShrinkRequest(TeaModel):
             result['description'] = self.description
         if self.fc_version is not None:
             result['fcVersion'] = self.fc_version
+        if self.function_name is not None:
+            result['functionName'] = self.function_name
         if self.gpu_type is not None:
             result['gpuType'] = self.gpu_type
         if self.limit is not None:
@@ -8564,6 +9880,8 @@ class ListFunctionsShrinkRequest(TeaModel):
             result['nextToken'] = self.next_token
         if self.prefix is not None:
             result['prefix'] = self.prefix
+        if self.resource_group_id is not None:
+            result['resourceGroupId'] = self.resource_group_id
         if self.runtime is not None:
             result['runtime'] = self.runtime
         if self.tags_shrink is not None:
@@ -8576,6 +9894,8 @@ class ListFunctionsShrinkRequest(TeaModel):
             self.description = m.get('description')
         if m.get('fcVersion') is not None:
             self.fc_version = m.get('fcVersion')
+        if m.get('functionName') is not None:
+            self.function_name = m.get('functionName')
         if m.get('gpuType') is not None:
             self.gpu_type = m.get('gpuType')
         if m.get('limit') is not None:
@@ -8584,6 +9904,8 @@ class ListFunctionsShrinkRequest(TeaModel):
             self.next_token = m.get('nextToken')
         if m.get('prefix') is not None:
             self.prefix = m.get('prefix')
+        if m.get('resourceGroupId') is not None:
+            self.resource_group_id = m.get('resourceGroupId')
         if m.get('runtime') is not None:
             self.runtime = m.get('runtime')
         if m.get('tags') is not None: