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

alibabacloud_fc20230330/models.py

@@ -2350,6 +2350,39 @@ class CreateLayerVersionInput(TeaModel):
         return self
 
 
+class CreateSessionInput(TeaModel):
+    def __init__(
+        self,
+        session_idle_timeout_in_seconds: int = None,
+        session_ttlin_seconds: int = None,
+    ):
+        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_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('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 CreateTriggerInput(TeaModel):
     def __init__(
         self,
@@ -2844,6 +2877,7 @@ class ElasticConfigStatus(TeaModel):
         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
@@ -2852,6 +2886,7 @@ class ElasticConfigStatus(TeaModel):
         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:
@@ -2887,6 +2922,8 @@ class ElasticConfigStatus(TeaModel):
         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):
@@ -2911,6 +2948,8 @@ class ElasticConfigStatus(TeaModel):
             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
 
 
@@ -4234,48 +4273,10 @@ class GetResourceTagsOutput(TeaModel):
         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):
+class GetScalingConfigStatusOutput(TeaModel):
+    def __init__(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
 
@@ -4285,103 +4286,10 @@ class ScalingStatus(TeaModel):
             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 GetScalingConfigStatusOutput(TeaModel):
-    def __init__(
-        self,
-        scaling_config_status: ScalingConfigStatus = None,
-    ):
-        self.scaling_config_status = scaling_config_status
-
-    def validate(self):
-        if self.scaling_config_status:
-            self.scaling_config_status.validate()
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        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('scalingConfigStatus') is not None:
-            temp_model = ScalingConfigStatus()
-            self.scaling_config_status = temp_model.from_map(m['scalingConfigStatus'])
         return self
 
 
@@ -5472,14 +5380,16 @@ class ResidentResourceAllocationStatus(TeaModel):
     def __init__(
         self,
         last_allocated_time: str = None,
-        last_allocation: ResidentResourceAllocation = 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:
-            self.last_allocation.validate()
+            for k in self.last_allocation:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -5489,17 +5399,21 @@ class ResidentResourceAllocationStatus(TeaModel):
         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:
-            result['lastAllocation'] = self.last_allocation.to_map()
+            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:
-            temp_model = ResidentResourceAllocation()
-            self.last_allocation = temp_model.from_map(m['lastAllocation'])
+            for k in m.get('lastAllocation'):
+                temp_model = ResidentResourceAllocation()
+                self.last_allocation.append(temp_model.from_map(k))
         return self
 
 
@@ -5693,19 +5607,11 @@ class ListResidentResourcePoolsOutput(TeaModel):
 
 
 class ListScalingConfigStatusOutput(TeaModel):
-    def __init__(
-        self,
-        next_token: str = None,
-        result: List[ScalingConfigStatus] = None,
-    ):
-        self.next_token = next_token
-        self.result = result
+    def __init__(self):
+        pass
 
     def validate(self):
-        if self.result:
-            for k in self.result:
-                if k:
-                    k.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -5713,41 +5619,43 @@ class ListScalingConfigStatusOutput(TeaModel):
             return _map
 
         result = dict()
-        if self.next_token is not None:
-            result['nextToken'] = self.next_token
-        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.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
 
 
-class TagResource(TeaModel):
+class ScalingConfigStatus(TeaModel):
     def __init__(
         self,
-        resource_id: str = None,
-        resource_type: str = None,
-        tag_key: str = None,
-        tag_value: str = None,
+        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.resource_id = resource_id
-        self.resource_type = resource_type
-        self.tag_key = tag_key
-        self.tag_value = tag_value
+        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):
-        pass
+        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()
@@ -5755,43 +5663,67 @@ 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
+        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('ResourceId') is not None:
-            self.resource_id = m.get('ResourceId')
-        if m.get('ResourceType') is not None:
-            self.resource_type = m.get('ResourceType')
-        if m.get('TagKey') is not None:
-            self.tag_key = m.get('TagKey')
-        if m.get('TagValue') is not None:
-            self.tag_value = m.get('TagValue')
+        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 ListTagResourcesOutput(TeaModel):
+class ListScalingConfigsOutput(TeaModel):
     def __init__(
         self,
         next_token: str = None,
-        request_id: str = None,
-        tag_resources: List[TagResource] = None,
+        scaling_configs: List[ScalingConfigStatus] = None,
     ):
         self.next_token = next_token
-        self.request_id = request_id
-        self.tag_resources = tag_resources
+        self.scaling_configs = scaling_configs
 
     def validate(self):
-        if self.tag_resources:
-            for k in self.tag_resources:
+        if self.scaling_configs:
+            for k in self.scaling_configs:
                 if k:
                     k.validate()
 
@@ -5802,27 +5734,237 @@ class ListTagResourcesOutput(TeaModel):
 
         result = dict()
         if self.next_token is not None:
-            result['NextToken'] = self.next_token
-        if self.request_id is not None:
-            result['RequestId'] = self.request_id
-        result['TagResources'] = []
-        if self.tag_resources is not None:
-            for k in self.tag_resources:
-                result['TagResources'].append(k.to_map() if k else 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')
-        if m.get('RequestId') is not None:
-            self.request_id = m.get('RequestId')
-        self.tag_resources = []
-        if m.get('TagResources') is not None:
-            for k in m.get('TagResources'):
-                temp_model = TagResource()
-                self.tag_resources.append(temp_model.from_map(k))
-        return self
+        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 Session(TeaModel):
+    def __init__(
+        self,
+        container_id: str = None,
+        created_time: str = None,
+        function_name: str = None,
+        last_modified_time: str = None,
+        qualifier: str = None,
+        session_affinity_type: str = None,
+        session_id: str = None,
+        session_idle_timeout_in_seconds: int = None,
+        session_status: str = None,
+        session_ttlin_seconds: int = None,
+    ):
+        self.container_id = container_id
+        self.created_time = created_time
+        self.function_name = function_name
+        self.last_modified_time = last_modified_time
+        self.qualifier = qualifier
+        self.session_affinity_type = session_affinity_type
+        self.session_id = session_id
+        self.session_idle_timeout_in_seconds = session_idle_timeout_in_seconds
+        self.session_status = session_status
+        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.container_id is not None:
+            result['containerId'] = self.container_id
+        if self.created_time is not None:
+            result['createdTime'] = self.created_time
+        if self.function_name is not None:
+            result['functionName'] = self.function_name
+        if self.last_modified_time is not None:
+            result['lastModifiedTime'] = self.last_modified_time
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        if self.session_affinity_type is not None:
+            result['sessionAffinityType'] = self.session_affinity_type
+        if self.session_id is not None:
+            result['sessionId'] = self.session_id
+        if self.session_idle_timeout_in_seconds is not None:
+            result['sessionIdleTimeoutInSeconds'] = self.session_idle_timeout_in_seconds
+        if self.session_status is not None:
+            result['sessionStatus'] = self.session_status
+        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('containerId') is not None:
+            self.container_id = m.get('containerId')
+        if m.get('createdTime') is not None:
+            self.created_time = m.get('createdTime')
+        if m.get('functionName') is not None:
+            self.function_name = m.get('functionName')
+        if m.get('lastModifiedTime') is not None:
+            self.last_modified_time = m.get('lastModifiedTime')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        if m.get('sessionAffinityType') is not None:
+            self.session_affinity_type = m.get('sessionAffinityType')
+        if m.get('sessionId') is not None:
+            self.session_id = m.get('sessionId')
+        if m.get('sessionIdleTimeoutInSeconds') is not None:
+            self.session_idle_timeout_in_seconds = m.get('sessionIdleTimeoutInSeconds')
+        if m.get('sessionStatus') is not None:
+            self.session_status = m.get('sessionStatus')
+        if m.get('sessionTTLInSeconds') is not None:
+            self.session_ttlin_seconds = m.get('sessionTTLInSeconds')
+        return self
+
+
+class ListSessionsOutput(TeaModel):
+    def __init__(
+        self,
+        next_token: str = None,
+        sessions: List[Session] = None,
+    ):
+        self.next_token = next_token
+        self.sessions = sessions
+
+    def validate(self):
+        if self.sessions:
+            for k in self.sessions:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        result['sessions'] = []
+        if self.sessions is not None:
+            for k in self.sessions:
+                result['sessions'].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.sessions = []
+        if m.get('sessions') is not None:
+            for k in m.get('sessions'):
+                temp_model = Session()
+                self.sessions.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')
+        if m.get('ResourceType') is not None:
+            self.resource_type = m.get('ResourceType')
+        if m.get('TagKey') is not None:
+            self.tag_key = m.get('TagKey')
+        if m.get('TagValue') is not None:
+            self.tag_value = m.get('TagValue')
+        return self
+
+
+class ListTagResourcesOutput(TeaModel):
+    def __init__(
+        self,
+        next_token: str = None,
+        request_id: str = None,
+        tag_resources: List[TagResource] = None,
+    ):
+        self.next_token = next_token
+        self.request_id = request_id
+        self.tag_resources = tag_resources
+
+    def validate(self):
+        if self.tag_resources:
+            for k in self.tag_resources:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.next_token is not None:
+            result['NextToken'] = self.next_token
+        if self.request_id is not None:
+            result['RequestId'] = self.request_id
+        result['TagResources'] = []
+        if self.tag_resources is not None:
+            for k in self.tag_resources:
+                result['TagResources'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('NextToken') is not None:
+            self.next_token = m.get('NextToken')
+        if m.get('RequestId') is not None:
+            self.request_id = m.get('RequestId')
+        self.tag_resources = []
+        if m.get('TagResources') is not None:
+            for k in m.get('TagResources'):
+                temp_model = TagResource()
+                self.tag_resources.append(temp_model.from_map(k))
+        return self
 
 
 class Resource(TeaModel):
@@ -6587,15 +6729,25 @@ class PutProvisionConfigInput(TeaModel):
 class PutScalingConfigInput(TeaModel):
     def __init__(
         self,
-        resident_config: ResidentConfig = None,
-        resource_type: str = None,
+        horizontal_scaling_policies: List[ScalingPolicy] = None,
+        min_instances: int = None,
+        resident_pool_id: str = None,
+        scheduled_policies: List[ScheduledPolicy] = None,
     ):
-        self.resident_config = resident_config
-        self.resource_type = resource_type
+        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.resident_config:
-            self.resident_config.validate()
+        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()
@@ -6603,38 +6755,70 @@ class PutScalingConfigInput(TeaModel):
             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
+        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()
-        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')
+        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,
-        function_name: str = None,
-        qualifier: str = None,
-        resident_config: ResidentConfig = None,
-        resource_type: str = None,
+        count: int = None,
+        pool_id: str = None,
     ):
-        self.function_name = function_name
-        self.qualifier = qualifier
-        self.resident_config = resident_config
-        self.resource_type = resource_type
+        self.count = count
+        self.pool_id = pool_id
 
     def validate(self):
-        if self.resident_config:
-            self.resident_config.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -6642,27 +6826,18 @@ class PutScalingConfigOutput(TeaModel):
             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.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('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('count') is not None:
+            self.count = m.get('count')
+        if m.get('poolId') is not None:
+            self.pool_id = m.get('poolId')
         return self
 
 
@@ -6791,6 +6966,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,
@@ -7249,8 +7457,10 @@ 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
@@ -7263,12 +7473,49 @@ class UpdateResidentResourcePoolInput(TeaModel):
         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 UpdateSessionInput(TeaModel):
+    def __init__(
+        self,
+        session_idle_timeout_in_seconds: int = None,
+        session_ttlin_seconds: int = None,
+    ):
+        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_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('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
 
 
@@ -7643,7 +7890,83 @@ class CreateLayerVersionResponse(TeaModel):
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: Layer = None,
+        body: Layer = 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 = Layer()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class CreateSessionRequest(TeaModel):
+    def __init__(
+        self,
+        body: CreateSessionInput = 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 = CreateSessionInput()
+            self.body = temp_model.from_map(m['body'])
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class CreateSessionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: Session = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -7674,7 +7997,7 @@ class CreateLayerVersionResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = Layer()
+            temp_model = Session()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -8137,6 +8460,126 @@ class DeleteProvisionConfigResponse(TeaModel):
         return self
 
 
+class DeleteScalingConfigRequest(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 DeleteScalingConfigResponse(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 DeleteSessionRequest(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 DeleteSessionResponse(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 DeleteTriggerResponse(TeaModel):
     def __init__(
         self,
@@ -8709,11 +9152,153 @@ class GetFunctionRequest(TeaModel):
         self,
         qualifier: str = None,
     ):
-        # 2023-03-10T10:10:10Z
-        self.qualifier = qualifier
+        # 2023-03-10T10:10:10Z
+        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 GetFunctionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: Function = 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 = Function()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetFunctionCodeRequest(TeaModel):
+    def __init__(
+        self,
+        qualifier: str = None,
+    ):
+        # The version or alias of the function.
+        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 GetFunctionCodeResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: OutputFuncCode = 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 = OutputFuncCode()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetLayerVersionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: Layer = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        pass
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -8721,23 +9306,32 @@ class GetFunctionRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.qualifier is not None:
-            result['qualifier'] = self.qualifier
+        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('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')
+        if m.get('body') is not None:
+            temp_model = Layer()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetFunctionResponse(TeaModel):
+class GetLayerVersionByArnResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: Function = None,
+        body: Layer = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -8768,17 +9362,17 @@ class GetFunctionResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = Function()
+            temp_model = Layer()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetFunctionCodeRequest(TeaModel):
+class GetProvisionConfigRequest(TeaModel):
     def __init__(
         self,
         qualifier: str = None,
     ):
-        # The version or alias of the function.
+        # The function alias.
         self.qualifier = qualifier
 
     def validate(self):
@@ -8801,12 +9395,12 @@ class GetFunctionCodeRequest(TeaModel):
         return self
 
 
-class GetFunctionCodeResponse(TeaModel):
+class GetProvisionConfigResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: OutputFuncCode = None,
+        body: ProvisionConfig = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -8837,25 +9431,20 @@ class GetFunctionCodeResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = OutputFuncCode()
+            temp_model = ProvisionConfig()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetLayerVersionResponse(TeaModel):
+class GetScalingConfigRequest(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: Layer = None,
+        qualifier: str = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
-        self.body = body
+        self.qualifier = qualifier
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -8863,32 +9452,23 @@ class GetLayerVersionResponse(TeaModel):
             return _map
 
         result = dict()
-        if self.headers is not None:
-            result['headers'] = self.headers
-        if self.status_code is not None:
-            result['statusCode'] = self.status_code
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        if self.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('body') is not None:
-            temp_model = Layer()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
         return self
 
 
-class GetLayerVersionByArnResponse(TeaModel):
+class GetScalingConfigResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: Layer = None,
+        body: ScalingConfigStatus = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -8919,17 +9499,16 @@ class GetLayerVersionByArnResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = Layer()
+            temp_model = ScalingConfigStatus()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetProvisionConfigRequest(TeaModel):
+class GetSessionRequest(TeaModel):
     def __init__(
         self,
         qualifier: str = None,
     ):
-        # The function alias.
         self.qualifier = qualifier
 
     def validate(self):
@@ -8952,12 +9531,12 @@ class GetProvisionConfigRequest(TeaModel):
         return self
 
 
-class GetProvisionConfigResponse(TeaModel):
+class GetSessionResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ProvisionConfig = None,
+        body: Session = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -8988,7 +9567,7 @@ class GetProvisionConfigResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ProvisionConfig()
+            temp_model = Session()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -10077,31 +10656,204 @@ class ListInstancesShrinkRequest(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('endTimeMs') is not None:
-            self.end_time_ms = m.get('endTimeMs')
-        if m.get('instanceIds') is not None:
-            self.instance_ids_shrink = m.get('instanceIds')
-        if m.get('instanceStatus') is not None:
-            self.instance_status_shrink = m.get('instanceStatus')
+        if m.get('endTimeMs') is not None:
+            self.end_time_ms = m.get('endTimeMs')
+        if m.get('instanceIds') is not None:
+            self.instance_ids_shrink = m.get('instanceIds')
+        if m.get('instanceStatus') is not None:
+            self.instance_status_shrink = m.get('instanceStatus')
+        if m.get('limit') is not None:
+            self.limit = m.get('limit')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        if m.get('startKey') is not None:
+            self.start_key = m.get('startKey')
+        if m.get('startTimeMs') is not None:
+            self.start_time_ms = m.get('startTimeMs')
+        if m.get('withAllActive') is not None:
+            self.with_all_active = m.get('withAllActive')
+        return self
+
+
+class ListInstancesResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListInstancesOutput = 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 = ListInstancesOutput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListLayerVersionsRequest(TeaModel):
+    def __init__(
+        self,
+        limit: int = None,
+        start_version: str = None,
+    ):
+        # The number of versions to be returned.
+        self.limit = limit
+        # The initial version of the layer.
+        self.start_version = start_version
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.limit is not None:
+            result['limit'] = self.limit
+        if self.start_version is not None:
+            result['startVersion'] = self.start_version
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('limit') is not None:
+            self.limit = m.get('limit')
+        if m.get('startVersion') is not None:
+            self.start_version = m.get('startVersion')
+        return self
+
+
+class ListLayerVersionsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListLayerVersionOutput = 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 = ListLayerVersionOutput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListLayersRequest(TeaModel):
+    def __init__(
+        self,
+        limit: int = None,
+        next_token: str = None,
+        official: str = None,
+        prefix: str = None,
+        public: str = None,
+    ):
+        # The number of layers that are returned
+        self.limit = limit
+        # The pagination token that is used in the next request to retrieve a new page of results.
+        self.next_token = next_token
+        # Specifies whether the layer is official. Valid values: true and false.
+        self.official = official
+        # The name prefix of the layer.
+        self.prefix = prefix
+        # Specifies whether the layer is public. Valid values: true and false.
+        self.public = public
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.limit is not None:
+            result['limit'] = self.limit
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        if self.official is not None:
+            result['official'] = self.official
+        if self.prefix is not None:
+            result['prefix'] = self.prefix
+        if self.public is not None:
+            result['public'] = self.public
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
         if m.get('limit') is not None:
             self.limit = m.get('limit')
-        if m.get('qualifier') is not None:
-            self.qualifier = m.get('qualifier')
-        if m.get('startKey') is not None:
-            self.start_key = m.get('startKey')
-        if m.get('startTimeMs') is not None:
-            self.start_time_ms = m.get('startTimeMs')
-        if m.get('withAllActive') is not None:
-            self.with_all_active = m.get('withAllActive')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        if m.get('official') is not None:
+            self.official = m.get('official')
+        if m.get('prefix') is not None:
+            self.prefix = m.get('prefix')
+        if m.get('public') is not None:
+            self.public = m.get('public')
         return self
 
 
-class ListInstancesResponse(TeaModel):
+class ListLayersResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListInstancesOutput = None,
+        body: ListLayersOutput = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10132,21 +10884,24 @@ class ListInstancesResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListInstancesOutput()
+            temp_model = ListLayersOutput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListLayerVersionsRequest(TeaModel):
+class ListProvisionConfigsRequest(TeaModel):
     def __init__(
         self,
+        function_name: str = None,
         limit: int = None,
-        start_version: str = None,
+        next_token: str = None,
     ):
-        # The number of versions to be returned.
+        # The name of the function. If this parameter is not specified, the provisioned configurations of all functions are listed.
+        self.function_name = function_name
+        # Number of provisioned configurations to return.
         self.limit = limit
-        # The initial version of the layer.
-        self.start_version = start_version
+        # A pagination token.
+        self.next_token = next_token
 
     def validate(self):
         pass
@@ -10157,27 +10912,31 @@ class ListLayerVersionsRequest(TeaModel):
             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.start_version is not None:
-            result['startVersion'] = self.start_version
+        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('startVersion') is not None:
-            self.start_version = m.get('startVersion')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
         return self
 
 
-class ListLayerVersionsResponse(TeaModel):
+class ListProvisionConfigsResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListLayerVersionOutput = None,
+        body: ListProvisionConfigsOutput = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10208,30 +10967,21 @@ class ListLayerVersionsResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListLayerVersionOutput()
+            temp_model = ListProvisionConfigsOutput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListLayersRequest(TeaModel):
+class ListScalingConfigsRequest(TeaModel):
     def __init__(
         self,
+        function_name: str = None,
         limit: int = None,
         next_token: str = None,
-        official: str = None,
-        prefix: str = None,
-        public: str = None,
     ):
-        # The number of layers that are returned
+        self.function_name = function_name
         self.limit = limit
-        # The pagination token that is used in the next request to retrieve a new page of results.
         self.next_token = next_token
-        # Specifies whether the layer is official. Valid values: true and false.
-        self.official = official
-        # The name prefix of the layer.
-        self.prefix = prefix
-        # Specifies whether the layer is public. Valid values: true and false.
-        self.public = public
 
     def validate(self):
         pass
@@ -10242,39 +10992,31 @@ class ListLayersRequest(TeaModel):
             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
-        if self.official is not None:
-            result['official'] = self.official
-        if self.prefix is not None:
-            result['prefix'] = self.prefix
-        if self.public is not None:
-            result['public'] = self.public
         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')
-        if m.get('official') is not None:
-            self.official = m.get('official')
-        if m.get('prefix') is not None:
-            self.prefix = m.get('prefix')
-        if m.get('public') is not None:
-            self.public = m.get('public')
         return self
 
 
-class ListLayersResponse(TeaModel):
+class ListScalingConfigsResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListLayersOutput = None,
+        body: ListScalingConfigsOutput = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10305,24 +11047,25 @@ class ListLayersResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListLayersOutput()
+            temp_model = ListScalingConfigsOutput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListProvisionConfigsRequest(TeaModel):
+class ListSessionsRequest(TeaModel):
     def __init__(
         self,
-        function_name: str = None,
         limit: int = None,
         next_token: str = None,
+        qualifier: str = None,
+        session_id: str = None,
+        session_status: str = None,
     ):
-        # The name of the function. If this parameter is not specified, the provisioned configurations of all functions are listed.
-        self.function_name = function_name
-        # Number of provisioned configurations to return.
         self.limit = limit
-        # A pagination token.
         self.next_token = next_token
+        self.qualifier = qualifier
+        self.session_id = session_id
+        self.session_status = session_status
 
     def validate(self):
         pass
@@ -10333,31 +11076,39 @@ class ListProvisionConfigsRequest(TeaModel):
             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
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        if self.session_id is not None:
+            result['sessionId'] = self.session_id
+        if self.session_status is not None:
+            result['sessionStatus'] = self.session_status
         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')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        if m.get('sessionId') is not None:
+            self.session_id = m.get('sessionId')
+        if m.get('sessionStatus') is not None:
+            self.session_status = m.get('sessionStatus')
         return self
 
 
-class ListProvisionConfigsResponse(TeaModel):
+class ListSessionsResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListProvisionConfigsOutput = None,
+        body: ListSessionsOutput = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10388,7 +11139,7 @@ class ListProvisionConfigsResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListProvisionConfigsOutput()
+            temp_model = ListSessionsOutput()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -11099,6 +11850,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,
@@ -11583,6 +12410,82 @@ class UpdateFunctionResponse(TeaModel):
         return self
 
 
+class UpdateSessionRequest(TeaModel):
+    def __init__(
+        self,
+        body: UpdateSessionInput = 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 = UpdateSessionInput()
+            self.body = temp_model.from_map(m['body'])
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class UpdateSessionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: Session = 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 = Session()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class UpdateTriggerRequest(TeaModel):
     def __init__(
         self,