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

alibabacloud_fc20230330/client.py

@@ -555,6 +555,116 @@ class Client(OpenApiClient):
         headers = {}
         return await self.create_layer_version_with_options_async(layer_name, request, headers, runtime)
 
+    def create_session_with_options(
+        self,
+        function_name: str,
+        request: fc20230330_models.CreateSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.CreateSessionResponse:
+        """
+        @summary 创建会话资源
+        
+        @param request: CreateSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: CreateSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='CreateSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.CreateSessionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def create_session_with_options_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.CreateSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.CreateSessionResponse:
+        """
+        @summary 创建会话资源
+        
+        @param request: CreateSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: CreateSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='CreateSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.CreateSessionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def create_session(
+        self,
+        function_name: str,
+        request: fc20230330_models.CreateSessionRequest,
+    ) -> fc20230330_models.CreateSessionResponse:
+        """
+        @summary 创建会话资源
+        
+        @param request: CreateSessionRequest
+        @return: CreateSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.create_session_with_options(function_name, request, headers, runtime)
+
+    async def create_session_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.CreateSessionRequest,
+    ) -> fc20230330_models.CreateSessionResponse:
+        """
+        @summary 创建会话资源
+        
+        @param request: CreateSessionRequest
+        @return: CreateSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.create_session_with_options_async(function_name, request, headers, runtime)
+
     def create_trigger_with_options(
         self,
         function_name: str,
@@ -1527,6 +1637,226 @@ class Client(OpenApiClient):
         headers = {}
         return await self.delete_provision_config_with_options_async(function_name, request, headers, runtime)
 
+    def delete_scaling_config_with_options(
+        self,
+        function_name: str,
+        request: fc20230330_models.DeleteScalingConfigRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.DeleteScalingConfigResponse:
+        """
+        @summary 删除弹性配置
+        
+        @param request: DeleteScalingConfigRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: DeleteScalingConfigResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='DeleteScalingConfig',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
+            method='DELETE',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='none'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.DeleteScalingConfigResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def delete_scaling_config_with_options_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.DeleteScalingConfigRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.DeleteScalingConfigResponse:
+        """
+        @summary 删除弹性配置
+        
+        @param request: DeleteScalingConfigRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: DeleteScalingConfigResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='DeleteScalingConfig',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
+            method='DELETE',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='none'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.DeleteScalingConfigResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def delete_scaling_config(
+        self,
+        function_name: str,
+        request: fc20230330_models.DeleteScalingConfigRequest,
+    ) -> fc20230330_models.DeleteScalingConfigResponse:
+        """
+        @summary 删除弹性配置
+        
+        @param request: DeleteScalingConfigRequest
+        @return: DeleteScalingConfigResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.delete_scaling_config_with_options(function_name, request, headers, runtime)
+
+    async def delete_scaling_config_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.DeleteScalingConfigRequest,
+    ) -> fc20230330_models.DeleteScalingConfigResponse:
+        """
+        @summary 删除弹性配置
+        
+        @param request: DeleteScalingConfigRequest
+        @return: DeleteScalingConfigResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.delete_scaling_config_with_options_async(function_name, request, headers, runtime)
+
+    def delete_session_with_options(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.DeleteSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.DeleteSessionResponse:
+        """
+        @summary 删除会话资源
+        
+        @param request: DeleteSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: DeleteSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='DeleteSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='DELETE',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='none'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.DeleteSessionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def delete_session_with_options_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.DeleteSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.DeleteSessionResponse:
+        """
+        @summary 删除会话资源
+        
+        @param request: DeleteSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: DeleteSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='DeleteSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='DELETE',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='none'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.DeleteSessionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def delete_session(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.DeleteSessionRequest,
+    ) -> fc20230330_models.DeleteSessionResponse:
+        """
+        @summary 删除会话资源
+        
+        @param request: DeleteSessionRequest
+        @return: DeleteSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.delete_session_with_options(function_name, session_id, request, headers, runtime)
+
+    async def delete_session_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.DeleteSessionRequest,
+    ) -> fc20230330_models.DeleteSessionResponse:
+        """
+        @summary 删除会话资源
+        
+        @param request: DeleteSessionRequest
+        @return: DeleteSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.delete_session_with_options_async(function_name, session_id, request, headers, runtime)
+
     def delete_trigger_with_options(
         self,
         function_name: str,
@@ -3031,28 +3361,34 @@ class Client(OpenApiClient):
         headers = {}
         return await self.get_provision_config_with_options_async(function_name, request, headers, runtime)
 
-    def get_trigger_with_options(
+    def get_scaling_config_with_options(
         self,
         function_name: str,
-        trigger_name: str,
+        request: fc20230330_models.GetScalingConfigRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> fc20230330_models.GetTriggerResponse:
+    ) -> fc20230330_models.GetScalingConfigResponse:
         """
-        @summary Queries information about a trigger.
+        @summary 获取弹性配置
         
+        @param request: GetScalingConfigRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: GetTriggerResponse
+        @return: GetScalingConfigResponse
         """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
         req = open_api_models.OpenApiRequest(
-            headers=headers
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='GetTrigger',
+            action='GetScalingConfig',
             version='2023-03-30',
             protocol='HTTPS',
-            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/triggers/{OpenApiUtilClient.get_encode_param(trigger_name)}',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
             method='GET',
             auth_type='AK',
             style='ROA',
@@ -3060,27 +3396,241 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            fc20230330_models.GetTriggerResponse(),
+            fc20230330_models.GetScalingConfigResponse(),
             self.call_api(params, req, runtime)
         )
 
-    async def get_trigger_with_options_async(
+    async def get_scaling_config_with_options_async(
         self,
         function_name: str,
-        trigger_name: str,
+        request: fc20230330_models.GetScalingConfigRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> fc20230330_models.GetTriggerResponse:
+    ) -> fc20230330_models.GetScalingConfigResponse:
         """
-        @summary Queries information about a trigger.
+        @summary 获取弹性配置
         
+        @param request: GetScalingConfigRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: GetTriggerResponse
+        @return: GetScalingConfigResponse
         """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
         req = open_api_models.OpenApiRequest(
-            headers=headers
-        )
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetScalingConfig',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.GetScalingConfigResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_scaling_config(
+        self,
+        function_name: str,
+        request: fc20230330_models.GetScalingConfigRequest,
+    ) -> fc20230330_models.GetScalingConfigResponse:
+        """
+        @summary 获取弹性配置
+        
+        @param request: GetScalingConfigRequest
+        @return: GetScalingConfigResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.get_scaling_config_with_options(function_name, request, headers, runtime)
+
+    async def get_scaling_config_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.GetScalingConfigRequest,
+    ) -> fc20230330_models.GetScalingConfigResponse:
+        """
+        @summary 获取弹性配置
+        
+        @param request: GetScalingConfigRequest
+        @return: GetScalingConfigResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.get_scaling_config_with_options_async(function_name, request, headers, runtime)
+
+    def get_session_with_options(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.GetSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.GetSessionResponse:
+        """
+        @summary 获取函数会话信息。
+        
+        @param request: GetSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.GetSessionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_session_with_options_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.GetSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.GetSessionResponse:
+        """
+        @summary 获取函数会话信息。
+        
+        @param request: GetSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.GetSessionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_session(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.GetSessionRequest,
+    ) -> fc20230330_models.GetSessionResponse:
+        """
+        @summary 获取函数会话信息。
+        
+        @param request: GetSessionRequest
+        @return: GetSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.get_session_with_options(function_name, session_id, request, headers, runtime)
+
+    async def get_session_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.GetSessionRequest,
+    ) -> fc20230330_models.GetSessionResponse:
+        """
+        @summary 获取函数会话信息。
+        
+        @param request: GetSessionRequest
+        @return: GetSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.get_session_with_options_async(function_name, session_id, request, headers, runtime)
+
+    def get_trigger_with_options(
+        self,
+        function_name: str,
+        trigger_name: str,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.GetTriggerResponse:
+        """
+        @summary Queries information about a trigger.
+        
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetTriggerResponse
+        """
+        req = open_api_models.OpenApiRequest(
+            headers=headers
+        )
+        params = open_api_models.Params(
+            action='GetTrigger',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/triggers/{OpenApiUtilClient.get_encode_param(trigger_name)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.GetTriggerResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_trigger_with_options_async(
+        self,
+        function_name: str,
+        trigger_name: str,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.GetTriggerResponse:
+        """
+        @summary Queries information about a trigger.
+        
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetTriggerResponse
+        """
+        req = open_api_models.OpenApiRequest(
+            headers=headers
+        )
         params = open_api_models.Params(
             action='GetTrigger',
             version='2023-03-30',
@@ -4627,6 +5177,242 @@ class Client(OpenApiClient):
         headers = {}
         return await self.list_provision_configs_with_options_async(request, headers, runtime)
 
+    def list_scaling_configs_with_options(
+        self,
+        request: fc20230330_models.ListScalingConfigsRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.ListScalingConfigsResponse:
+        """
+        @summary 获取弹性配置列表
+        
+        @param request: ListScalingConfigsRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListScalingConfigsResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.function_name):
+            query['functionName'] = request.function_name
+        if not UtilClient.is_unset(request.limit):
+            query['limit'] = request.limit
+        if not UtilClient.is_unset(request.next_token):
+            query['nextToken'] = request.next_token
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListScalingConfigs',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/scaling-configs',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.ListScalingConfigsResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_scaling_configs_with_options_async(
+        self,
+        request: fc20230330_models.ListScalingConfigsRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.ListScalingConfigsResponse:
+        """
+        @summary 获取弹性配置列表
+        
+        @param request: ListScalingConfigsRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListScalingConfigsResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.function_name):
+            query['functionName'] = request.function_name
+        if not UtilClient.is_unset(request.limit):
+            query['limit'] = request.limit
+        if not UtilClient.is_unset(request.next_token):
+            query['nextToken'] = request.next_token
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListScalingConfigs',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/scaling-configs',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.ListScalingConfigsResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_scaling_configs(
+        self,
+        request: fc20230330_models.ListScalingConfigsRequest,
+    ) -> fc20230330_models.ListScalingConfigsResponse:
+        """
+        @summary 获取弹性配置列表
+        
+        @param request: ListScalingConfigsRequest
+        @return: ListScalingConfigsResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.list_scaling_configs_with_options(request, headers, runtime)
+
+    async def list_scaling_configs_async(
+        self,
+        request: fc20230330_models.ListScalingConfigsRequest,
+    ) -> fc20230330_models.ListScalingConfigsResponse:
+        """
+        @summary 获取弹性配置列表
+        
+        @param request: ListScalingConfigsRequest
+        @return: ListScalingConfigsResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.list_scaling_configs_with_options_async(request, headers, runtime)
+
+    def list_sessions_with_options(
+        self,
+        function_name: str,
+        request: fc20230330_models.ListSessionsRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.ListSessionsResponse:
+        """
+        @summary 列出函数会话信息
+        
+        @param request: ListSessionsRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListSessionsResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.limit):
+            query['limit'] = request.limit
+        if not UtilClient.is_unset(request.next_token):
+            query['nextToken'] = request.next_token
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        if not UtilClient.is_unset(request.session_id):
+            query['sessionId'] = request.session_id
+        if not UtilClient.is_unset(request.session_status):
+            query['sessionStatus'] = request.session_status
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListSessions',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.ListSessionsResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_sessions_with_options_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.ListSessionsRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.ListSessionsResponse:
+        """
+        @summary 列出函数会话信息
+        
+        @param request: ListSessionsRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListSessionsResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.limit):
+            query['limit'] = request.limit
+        if not UtilClient.is_unset(request.next_token):
+            query['nextToken'] = request.next_token
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        if not UtilClient.is_unset(request.session_id):
+            query['sessionId'] = request.session_id
+        if not UtilClient.is_unset(request.session_status):
+            query['sessionStatus'] = request.session_status
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListSessions',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.ListSessionsResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_sessions(
+        self,
+        function_name: str,
+        request: fc20230330_models.ListSessionsRequest,
+    ) -> fc20230330_models.ListSessionsResponse:
+        """
+        @summary 列出函数会话信息
+        
+        @param request: ListSessionsRequest
+        @return: ListSessionsResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.list_sessions_with_options(function_name, request, headers, runtime)
+
+    async def list_sessions_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.ListSessionsRequest,
+    ) -> fc20230330_models.ListSessionsResponse:
+        """
+        @summary 列出函数会话信息
+        
+        @param request: ListSessionsRequest
+        @return: ListSessionsResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.list_sessions_with_options_async(function_name, request, headers, runtime)
+
     def list_tag_resources_with_options(
         self,
         tmp_req: fc20230330_models.ListTagResourcesRequest,
@@ -5501,6 +6287,116 @@ class Client(OpenApiClient):
         headers = {}
         return await self.put_provision_config_with_options_async(function_name, request, headers, runtime)
 
+    def put_scaling_config_with_options(
+        self,
+        function_name: str,
+        request: fc20230330_models.PutScalingConfigRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.PutScalingConfigResponse:
+        """
+        @summary 设置弹性配置
+        
+        @param request: PutScalingConfigRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: PutScalingConfigResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='PutScalingConfig',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.PutScalingConfigResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def put_scaling_config_with_options_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.PutScalingConfigRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.PutScalingConfigResponse:
+        """
+        @summary 设置弹性配置
+        
+        @param request: PutScalingConfigRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: PutScalingConfigResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='PutScalingConfig',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/scaling-config',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.PutScalingConfigResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def put_scaling_config(
+        self,
+        function_name: str,
+        request: fc20230330_models.PutScalingConfigRequest,
+    ) -> fc20230330_models.PutScalingConfigResponse:
+        """
+        @summary 设置弹性配置
+        
+        @param request: PutScalingConfigRequest
+        @return: PutScalingConfigResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.put_scaling_config_with_options(function_name, request, headers, runtime)
+
+    async def put_scaling_config_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.PutScalingConfigRequest,
+    ) -> fc20230330_models.PutScalingConfigResponse:
+        """
+        @summary 设置弹性配置
+        
+        @param request: PutScalingConfigRequest
+        @return: PutScalingConfigResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.put_scaling_config_with_options_async(function_name, request, headers, runtime)
+
     def stop_async_task_with_options(
         self,
         function_name: str,
@@ -6157,6 +7053,120 @@ class Client(OpenApiClient):
         headers = {}
         return await self.update_function_with_options_async(function_name, request, headers, runtime)
 
+    def update_session_with_options(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.UpdateSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.UpdateSessionResponse:
+        """
+        @summary 更新会话配置
+        
+        @param request: UpdateSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: UpdateSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='UpdateSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.UpdateSessionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def update_session_with_options_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.UpdateSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.UpdateSessionResponse:
+        """
+        @summary 更新会话配置
+        
+        @param request: UpdateSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: UpdateSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='UpdateSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.UpdateSessionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def update_session(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.UpdateSessionRequest,
+    ) -> fc20230330_models.UpdateSessionResponse:
+        """
+        @summary 更新会话配置
+        
+        @param request: UpdateSessionRequest
+        @return: UpdateSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.update_session_with_options(function_name, session_id, request, headers, runtime)
+
+    async def update_session_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.UpdateSessionRequest,
+    ) -> fc20230330_models.UpdateSessionResponse:
+        """
+        @summary 更新会话配置
+        
+        @param request: UpdateSessionRequest
+        @return: UpdateSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.update_session_with_options_async(function_name, session_id, request, headers, runtime)
+
     def update_trigger_with_options(
         self,
         function_name: str,