alibabacloud-fc20230330 4.2.7__py3-none-any.whl → 4.5.0__py3-none-any.whl

alibabacloud_fc20230330/models.py

@@ -646,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,
@@ -2030,6 +2069,7 @@ class CreateFunctionInput(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,
         layers: List[str] = None,
@@ -2041,6 +2081,7 @@ class CreateFunctionInput(TeaModel):
         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,
@@ -2062,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
@@ -2074,6 +2116,7 @@ class CreateFunctionInput(TeaModel):
         # 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
@@ -2141,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:
@@ -2163,6 +2208,8 @@ class CreateFunctionInput(TeaModel):
             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:
@@ -2210,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'])
@@ -2236,6 +2285,8 @@ class CreateFunctionInput(TeaModel):
             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'):
@@ -2657,6 +2708,218 @@ class DescribeRegionsOutput(TeaModel):
         return self
 
 
+class ScalingPolicy(TeaModel):
+    def __init__(
+        self,
+        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.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
+
+    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.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('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,
+        target_instances: int = 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
+        self.target_instances = target_instances
+
+    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)
+        if self.target_instances is not None:
+            result['targetInstances'] = self.target_instances
+        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))
+        if m.get('targetInstances') is not None:
+            self.target_instances = m.get('targetInstances')
+        return self
+
+
 class Error(TeaModel):
     def __init__(
         self,
@@ -3530,6 +3793,7 @@ 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: FunctionRestriction = None,
@@ -3546,6 +3810,7 @@ class Function(TeaModel):
         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,
@@ -3572,6 +3837,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
@@ -3588,6 +3854,7 @@ class Function(TeaModel):
         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
@@ -3670,6 +3937,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:
@@ -3704,6 +3973,8 @@ class Function(TeaModel):
             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:
@@ -3764,6 +4035,8 @@ 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'])
@@ -3804,6 +4077,8 @@ class Function(TeaModel):
             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:
@@ -3965,6 +4240,26 @@ class GetResourceTagsOutput(TeaModel):
         return self
 
 
+class GetScalingConfigStatusOutput(TeaModel):
+    def __init__(self):
+        pass
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        return self
+
+
 class HTTPTrigger(TeaModel):
     def __init__(
         self,
@@ -4043,6 +4338,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,
@@ -4461,6 +4801,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,
@@ -4892,18 +5273,31 @@ class ListProvisionConfigsOutput(TeaModel):
         return self
 
 
-class TagResource(TeaModel):
+class ResidentResourceAllocation(TeaModel):
     def __init__(
         self,
-        resource_id: str = None,
-        resource_type: str = None,
-        tag_key: str = None,
-        tag_value: str = None,
+        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.resource_id = resource_id
-        self.resource_type = resource_type
-        self.tag_key = tag_key
-        self.tag_value = tag_value
+        # 使用该资源池的函数名
+        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
@@ -4914,17 +5308,451 @@ class TagResource(TeaModel):
             return _map
 
         result = dict()
-        if self.resource_id is not None:
-            result['ResourceId'] = self.resource_id
-        if self.resource_type is not None:
-            result['ResourceType'] = self.resource_type
-        if self.tag_key is not None:
-            result['TagKey'] = self.tag_key
-        if self.tag_value is not None:
-            result['TagValue'] = self.tag_value
-        return result
-
-    def from_map(self, m: dict = None):
+        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: List[ResidentResourceAllocation] = None,
+    ):
+        self.last_allocated_time = last_allocated_time
+        self.last_allocation = last_allocation
+
+    def validate(self):
+        if self.last_allocation:
+            for k in self.last_allocation:
+                if k:
+                    k.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
+        result['lastAllocation'] = []
+        if self.last_allocation is not None:
+            for k in self.last_allocation:
+                result['lastAllocation'].append(k.to_map() if k else None)
+        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')
+        self.last_allocation = []
+        if m.get('lastAllocation') is not None:
+            for k in m.get('lastAllocation'):
+                temp_model = ResidentResourceAllocation()
+                self.last_allocation.append(temp_model.from_map(k))
+        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):
+        pass
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        return self
+
+
+class ScalingConfigStatus(TeaModel):
+    def __init__(
+        self,
+        current_error: str = None,
+        current_instances: int = None,
+        function_arn: str = None,
+        horizontal_scaling_policies: List[ScalingPolicy] = None,
+        min_instances: int = None,
+        resident_pool_id: str = None,
+        scheduled_policies: List[ScheduledPolicy] = None,
+        target_instances: int = None,
+    ):
+        self.current_error = current_error
+        self.current_instances = current_instances
+        self.function_arn = function_arn
+        self.horizontal_scaling_policies = horizontal_scaling_policies
+        self.min_instances = min_instances
+        self.resident_pool_id = resident_pool_id
+        self.scheduled_policies = scheduled_policies
+        self.target_instances = target_instances
+
+    def validate(self):
+        if self.horizontal_scaling_policies:
+            for k in self.horizontal_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
+        result['horizontalScalingPolicies'] = []
+        if self.horizontal_scaling_policies is not None:
+            for k in self.horizontal_scaling_policies:
+                result['horizontalScalingPolicies'].append(k.to_map() if k else None)
+        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['scheduledPolicies'] = []
+        if self.scheduled_policies is not None:
+            for k in self.scheduled_policies:
+                result['scheduledPolicies'].append(k.to_map() if k else None)
+        if self.target_instances is not None:
+            result['targetInstances'] = self.target_instances
+        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')
+        self.horizontal_scaling_policies = []
+        if m.get('horizontalScalingPolicies') is not None:
+            for k in m.get('horizontalScalingPolicies'):
+                temp_model = ScalingPolicy()
+                self.horizontal_scaling_policies.append(temp_model.from_map(k))
+        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.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))
+        if m.get('targetInstances') is not None:
+            self.target_instances = m.get('targetInstances')
+        return self
+
+
+class ListScalingConfigsOutput(TeaModel):
+    def __init__(
+        self,
+        next_token: str = None,
+        scaling_configs: List[ScalingConfigStatus] = None,
+    ):
+        self.next_token = next_token
+        self.scaling_configs = scaling_configs
+
+    def validate(self):
+        if self.scaling_configs:
+            for k in self.scaling_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['scalingConfigs'] = []
+        if self.scaling_configs is not None:
+            for k in self.scaling_configs:
+                result['scalingConfigs'].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.scaling_configs = []
+        if m.get('scalingConfigs') is not None:
+            for k in m.get('scalingConfigs'):
+                temp_model = ScalingConfigStatus()
+                self.scaling_configs.append(temp_model.from_map(k))
+        return self
+
+
+class TagResource(TeaModel):
+    def __init__(
+        self,
+        resource_id: str = None,
+        resource_type: str = None,
+        tag_key: str = None,
+        tag_value: str = None,
+    ):
+        self.resource_id = resource_id
+        self.resource_type = resource_type
+        self.tag_key = tag_key
+        self.tag_value = tag_value
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.resource_id is not None:
+            result['ResourceId'] = self.resource_id
+        if self.resource_type is not None:
+            result['ResourceType'] = self.resource_type
+        if self.tag_key is not None:
+            result['TagKey'] = self.tag_key
+        if self.tag_value is not None:
+            result['TagValue'] = self.tag_value
+        return result
+
+    def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('ResourceId') is not None:
             self.resource_id = m.get('ResourceId')
@@ -5325,6 +6153,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,
@@ -5506,16 +6406,56 @@ class PutAsyncInvokeConfigInput(TeaModel):
         return self
 
 
-class PutConcurrencyInput(TeaModel):
+class PutConcurrencyInput(TeaModel):
+    def __init__(
+        self,
+        reserved_concurrency: int = None,
+    ):
+        # This parameter is required.
+        self.reserved_concurrency = reserved_concurrency
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.reserved_concurrency is not None:
+            result['reservedConcurrency'] = self.reserved_concurrency
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('reservedConcurrency') is not None:
+            self.reserved_concurrency = m.get('reservedConcurrency')
+        return self
+
+
+class PutElasticConfigInput(TeaModel):
     def __init__(
         self,
-        reserved_concurrency: int = None,
+        min_instances: int = None,
+        resident_pool_id: str = None,
+        scaling_policies: List[ScalingPolicy] = None,
+        scheduled_policies: List[ScheduledPolicy] = None,
     ):
-        # This parameter is required.
-        self.reserved_concurrency = reserved_concurrency
+        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):
-        pass
+        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()
@@ -5523,14 +6463,36 @@ class PutConcurrencyInput(TeaModel):
             return _map
 
         result = dict()
-        if self.reserved_concurrency is not None:
-            result['reservedConcurrency'] = self.reserved_concurrency
+        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('reservedConcurrency') is not None:
-            self.reserved_concurrency = m.get('reservedConcurrency')
+        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
 
 
@@ -5609,6 +6571,121 @@ class PutProvisionConfigInput(TeaModel):
         return self
 
 
+class PutScalingConfigInput(TeaModel):
+    def __init__(
+        self,
+        horizontal_scaling_policies: List[ScalingPolicy] = None,
+        min_instances: int = None,
+        resident_pool_id: str = None,
+        scheduled_policies: List[ScheduledPolicy] = None,
+    ):
+        self.horizontal_scaling_policies = horizontal_scaling_policies
+        self.min_instances = min_instances
+        self.resident_pool_id = resident_pool_id
+        self.scheduled_policies = scheduled_policies
+
+    def validate(self):
+        if self.horizontal_scaling_policies:
+            for k in self.horizontal_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()
+        result['horizontalScalingPolicies'] = []
+        if self.horizontal_scaling_policies is not None:
+            for k in self.horizontal_scaling_policies:
+                result['horizontalScalingPolicies'].append(k.to_map() if k else None)
+        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['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()
+        self.horizontal_scaling_policies = []
+        if m.get('horizontalScalingPolicies') is not None:
+            for k in m.get('horizontalScalingPolicies'):
+                temp_model = ScalingPolicy()
+                self.horizontal_scaling_policies.append(temp_model.from_map(k))
+        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.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 PutScalingConfigOutput(TeaModel):
+    def __init__(self):
+        pass
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        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 SLSTriggerLogConfig(TeaModel):
     def __init__(
         self,
@@ -5734,6 +6811,39 @@ class SLSTriggerConfig(TeaModel):
         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 TagResourceInput(TeaModel):
     def __init__(
         self,
@@ -5983,6 +7093,7 @@ class UpdateFunctionInput(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,
         layers: List[str] = None,
@@ -5993,6 +7104,7 @@ class UpdateFunctionInput(TeaModel):
         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,
@@ -6010,6 +7122,7 @@ class UpdateFunctionInput(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.layers = layers
@@ -6020,6 +7133,7 @@ class UpdateFunctionInput(TeaModel):
         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
@@ -6080,6 +7194,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:
@@ -6100,6 +7216,8 @@ class UpdateFunctionInput(TeaModel):
             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:
@@ -6141,6 +7259,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'])
@@ -6165,6 +7285,8 @@ class UpdateFunctionInput(TeaModel):
             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:
@@ -6176,6 +7298,39 @@ class UpdateFunctionInput(TeaModel):
         return self
 
 
+class UpdateResidentResourcePoolInput(TeaModel):
+    def __init__(
+        self,
+        name: str = None,
+        use_scaling: bool = None,
+    ):
+        self.name = name
+        self.use_scaling = use_scaling
+
+    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
+        if self.use_scaling is not None:
+            result['useScaling'] = self.use_scaling
+        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')
+        if m.get('useScaling') is not None:
+            self.use_scaling = m.get('useScaling')
+        return self
+
+
 class UpdateTriggerInput(TeaModel):
     def __init__(
         self,
@@ -6221,6 +7376,76 @@ class UpdateTriggerInput(TeaModel):
         return self
 
 
+class ChangeResourceGroupRequest(TeaModel):
+    def __init__(
+        self,
+        body: ChangeResourceGroupInput = None,
+    ):
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.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('body') is not None:
+            temp_model = ChangeResourceGroupInput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ChangeResourceGroupResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ChangeResourceGroupOutput = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ChangeResourceGroupOutput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class CreateAliasRequest(TeaModel):
     def __init__(
         self,
@@ -6701,18 +7926,84 @@ class DeleteAsyncInvokeConfigRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.qualifier is not None:
-            result['qualifier'] = self.qualifier
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class DeleteAsyncInvokeConfigResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        return self
+
+
+class DeleteConcurrencyConfigResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('qualifier') is not None:
-            self.qualifier = m.get('qualifier')
+        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')
         return self
 
 
-class DeleteAsyncInvokeConfigResponse(TeaModel):
+class DeleteCustomDomainResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
@@ -6745,7 +8036,7 @@ class DeleteAsyncInvokeConfigResponse(TeaModel):
         return self
 
 
-class DeleteConcurrencyConfigResponse(TeaModel):
+class DeleteFunctionResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
@@ -6778,7 +8069,7 @@ class DeleteConcurrencyConfigResponse(TeaModel):
         return self
 
 
-class DeleteCustomDomainResponse(TeaModel):
+class DeleteFunctionVersionResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
@@ -6811,7 +8102,7 @@ class DeleteCustomDomainResponse(TeaModel):
         return self
 
 
-class DeleteFunctionResponse(TeaModel):
+class DeleteLayerVersionResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
@@ -6844,14 +8135,13 @@ class DeleteFunctionResponse(TeaModel):
         return self
 
 
-class DeleteFunctionVersionResponse(TeaModel):
+class DeleteProvisionConfigRequest(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
+        qualifier: str = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
+        # The function alias.
+        self.qualifier = qualifier
 
     def validate(self):
         pass
@@ -6862,22 +8152,18 @@ class DeleteFunctionVersionResponse(TeaModel):
             return _map
 
         result = dict()
-        if self.headers is not None:
-            result['headers'] = self.headers
-        if self.status_code is not None:
-            result['statusCode'] = self.status_code
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('headers') is not None:
-            self.headers = m.get('headers')
-        if m.get('statusCode') is not None:
-            self.status_code = m.get('statusCode')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
         return self
 
 
-class DeleteLayerVersionResponse(TeaModel):
+class DeleteProvisionConfigResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
@@ -6910,12 +8196,11 @@ class DeleteLayerVersionResponse(TeaModel):
         return self
 
 
-class DeleteProvisionConfigRequest(TeaModel):
+class DeleteScalingConfigRequest(TeaModel):
     def __init__(
         self,
         qualifier: str = None,
     ):
-        # The function alias.
         self.qualifier = qualifier
 
     def validate(self):
@@ -6938,7 +8223,7 @@ class DeleteProvisionConfigRequest(TeaModel):
         return self
 
 
-class DeleteProvisionConfigResponse(TeaModel):
+class DeleteScalingConfigResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
@@ -7827,6 +9112,74 @@ class GetProvisionConfigResponse(TeaModel):
         return self
 
 
+class GetScalingConfigRequest(TeaModel):
+    def __init__(
+        self,
+        qualifier: str = None,
+    ):
+        self.qualifier = qualifier
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class GetScalingConfigResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ScalingConfigStatus = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ScalingConfigStatus()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class GetTriggerResponse(TeaModel):
     def __init__(
         self,
@@ -9227,6 +10580,86 @@ class ListProvisionConfigsResponse(TeaModel):
         return self
 
 
+class ListScalingConfigsRequest(TeaModel):
+    def __init__(
+        self,
+        function_name: str = None,
+        limit: int = None,
+        next_token: str = None,
+    ):
+        self.function_name = function_name
+        self.limit = limit
+        self.next_token = next_token
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.function_name is not None:
+            result['functionName'] = self.function_name
+        if self.limit is not None:
+            result['limit'] = self.limit
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('functionName') is not None:
+            self.function_name = m.get('functionName')
+        if m.get('limit') is not None:
+            self.limit = m.get('limit')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        return self
+
+
+class ListScalingConfigsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListScalingConfigsOutput = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListScalingConfigsOutput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class ListTagResourcesRequestTag(TeaModel):
     def __init__(
         self,
@@ -9933,6 +11366,82 @@ class PutProvisionConfigResponse(TeaModel):
         return self
 
 
+class PutScalingConfigRequest(TeaModel):
+    def __init__(
+        self,
+        body: PutScalingConfigInput = None,
+        qualifier: str = None,
+    ):
+        self.body = body
+        self.qualifier = qualifier
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('body') is not None:
+            temp_model = PutScalingConfigInput()
+            self.body = temp_model.from_map(m['body'])
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class PutScalingConfigResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ScalingConfigStatus = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ScalingConfigStatus()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class StopAsyncTaskRequest(TeaModel):
     def __init__(
         self,