volcengine-python-sdk 4.0.17__py2.py3-none-any.whl → 4.0.19__py2.py3-none-any.whl

volcenginesdkapig/api/apig_api.py

@@ -33,6 +33,103 @@ class APIGApi(object):
             api_client = volcenginesdkcore.ApiClient()
         self.api_client = api_client
 
+    def attach_gateway_lb(self, body, **kwargs):  # noqa: E501
+        """attach_gateway_lb  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.attach_gateway_lb(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AttachGatewayLBRequest body: (required)
+        :return: AttachGatewayLBResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.attach_gateway_lb_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.attach_gateway_lb_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def attach_gateway_lb_with_http_info(self, body, **kwargs):  # noqa: E501
+        """attach_gateway_lb  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.attach_gateway_lb_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AttachGatewayLBRequest body: (required)
+        :return: AttachGatewayLBResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method attach_gateway_lb" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `attach_gateway_lb`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/AttachGatewayLB/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='AttachGatewayLBResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def create_consumer(self, body, **kwargs):  # noqa: E501
         """create_consumer  # noqa: E501
 
@@ -227,6 +324,103 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def create_custom_domain(self, body, **kwargs):  # noqa: E501
+        """create_custom_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.create_custom_domain(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateCustomDomainRequest body: (required)
+        :return: CreateCustomDomainResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.create_custom_domain_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.create_custom_domain_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def create_custom_domain_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_custom_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.create_custom_domain_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateCustomDomainRequest body: (required)
+        :return: CreateCustomDomainResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method create_custom_domain" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_custom_domain`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/CreateCustomDomain/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='CreateCustomDomainResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def create_gateway(self, body, **kwargs):  # noqa: E501
         """create_gateway  # noqa: E501
 
@@ -712,38 +906,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_consumer(self, body, **kwargs):  # noqa: E501
-        """delete_consumer  # noqa: E501
+    def create_upstream_version(self, body, **kwargs):  # noqa: E501
+        """create_upstream_version  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_consumer(body, async_req=True)
+        >>> thread = api.create_upstream_version(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteConsumerRequest body: (required)
-        :return: DeleteConsumerResponse
+        :param CreateUpstreamVersionRequest body: (required)
+        :return: CreateUpstreamVersionResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_consumer_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_upstream_version_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_consumer_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_upstream_version_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_consumer_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_consumer  # noqa: E501
+    def create_upstream_version_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_upstream_version  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_consumer_with_http_info(body, async_req=True)
+        >>> thread = api.create_upstream_version_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteConsumerRequest body: (required)
-        :return: DeleteConsumerResponse
+        :param CreateUpstreamVersionRequest body: (required)
+        :return: CreateUpstreamVersionResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -759,14 +953,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_consumer" % key
+                    " to method create_upstream_version" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `delete_consumer`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_upstream_version`")  # noqa: E501
 
         collection_formats = {}
 
@@ -794,14 +988,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteConsumer/2021-03-03/apig/post/application_json/', 'POST',
+            '/CreateUpstreamVersion/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteConsumerResponse',  # noqa: E501
+            response_type='CreateUpstreamVersionResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -809,38 +1003,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_consumer_credential(self, body, **kwargs):  # noqa: E501
-        """delete_consumer_credential  # noqa: E501
+    def delete_consumer(self, body, **kwargs):  # noqa: E501
+        """delete_consumer  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_consumer_credential(body, async_req=True)
+        >>> thread = api.delete_consumer(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteConsumerCredentialRequest body: (required)
-        :return: DeleteConsumerCredentialResponse
+        :param DeleteConsumerRequest body: (required)
+        :return: DeleteConsumerResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_consumer_credential_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_consumer_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_consumer_credential_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_consumer_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_consumer_credential_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_consumer_credential  # noqa: E501
+    def delete_consumer_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_consumer  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_consumer_credential_with_http_info(body, async_req=True)
+        >>> thread = api.delete_consumer_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteConsumerCredentialRequest body: (required)
-        :return: DeleteConsumerCredentialResponse
+        :param DeleteConsumerRequest body: (required)
+        :return: DeleteConsumerResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -856,14 +1050,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_consumer_credential" % key
+                    " to method delete_consumer" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `delete_consumer_credential`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_consumer`")  # noqa: E501
 
         collection_formats = {}
 
@@ -891,14 +1085,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteConsumerCredential/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeleteConsumer/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteConsumerCredentialResponse',  # noqa: E501
+            response_type='DeleteConsumerResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -906,38 +1100,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_gateway(self, body, **kwargs):  # noqa: E501
-        """delete_gateway  # noqa: E501
+    def delete_consumer_credential(self, body, **kwargs):  # noqa: E501
+        """delete_consumer_credential  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_gateway(body, async_req=True)
+        >>> thread = api.delete_consumer_credential(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteGatewayRequest body: (required)
-        :return: DeleteGatewayResponse
+        :param DeleteConsumerCredentialRequest body: (required)
+        :return: DeleteConsumerCredentialResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_gateway_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_consumer_credential_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_gateway_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_consumer_credential_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_gateway_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_gateway  # noqa: E501
+    def delete_consumer_credential_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_consumer_credential  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_gateway_with_http_info(body, async_req=True)
+        >>> thread = api.delete_consumer_credential_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteGatewayRequest body: (required)
-        :return: DeleteGatewayResponse
+        :param DeleteConsumerCredentialRequest body: (required)
+        :return: DeleteConsumerCredentialResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -953,14 +1147,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_gateway" % key
+                    " to method delete_consumer_credential" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `delete_gateway`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_consumer_credential`")  # noqa: E501
 
         collection_formats = {}
 
@@ -988,14 +1182,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteGateway/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeleteConsumerCredential/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteGatewayResponse',  # noqa: E501
+            response_type='DeleteConsumerCredentialResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1003,38 +1197,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_gateway_service(self, body, **kwargs):  # noqa: E501
-        """delete_gateway_service  # noqa: E501
+    def delete_custom_domain(self, body, **kwargs):  # noqa: E501
+        """delete_custom_domain  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_gateway_service(body, async_req=True)
+        >>> thread = api.delete_custom_domain(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteGatewayServiceRequest body: (required)
-        :return: DeleteGatewayServiceResponse
+        :param DeleteCustomDomainRequest body: (required)
+        :return: DeleteCustomDomainResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_gateway_service_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_custom_domain_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_gateway_service_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_custom_domain_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_gateway_service_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_gateway_service  # noqa: E501
+    def delete_custom_domain_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_custom_domain  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_gateway_service_with_http_info(body, async_req=True)
+        >>> thread = api.delete_custom_domain_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteGatewayServiceRequest body: (required)
-        :return: DeleteGatewayServiceResponse
+        :param DeleteCustomDomainRequest body: (required)
+        :return: DeleteCustomDomainResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1050,14 +1244,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_gateway_service" % key
+                    " to method delete_custom_domain" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `delete_gateway_service`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_custom_domain`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1085,14 +1279,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteGatewayService/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeleteCustomDomain/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteGatewayServiceResponse',  # noqa: E501
+            response_type='DeleteCustomDomainResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1100,38 +1294,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_plugin_binding(self, body, **kwargs):  # noqa: E501
-        """delete_plugin_binding  # noqa: E501
+    def delete_gateway(self, body, **kwargs):  # noqa: E501
+        """delete_gateway  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_plugin_binding(body, async_req=True)
+        >>> thread = api.delete_gateway(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeletePluginBindingRequest body: (required)
-        :return: DeletePluginBindingResponse
+        :param DeleteGatewayRequest body: (required)
+        :return: DeleteGatewayResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_plugin_binding_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_gateway_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_plugin_binding_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_gateway_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_plugin_binding_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_plugin_binding  # noqa: E501
+    def delete_gateway_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_gateway  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_plugin_binding_with_http_info(body, async_req=True)
+        >>> thread = api.delete_gateway_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeletePluginBindingRequest body: (required)
-        :return: DeletePluginBindingResponse
+        :param DeleteGatewayRequest body: (required)
+        :return: DeleteGatewayResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1147,14 +1341,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_plugin_binding" % key
+                    " to method delete_gateway" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `delete_plugin_binding`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_gateway`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1182,14 +1376,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeletePluginBinding/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeleteGateway/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeletePluginBindingResponse',  # noqa: E501
+            response_type='DeleteGatewayResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1197,38 +1391,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_upstream(self, body, **kwargs):  # noqa: E501
-        """delete_upstream  # noqa: E501
+    def delete_gateway_service(self, body, **kwargs):  # noqa: E501
+        """delete_gateway_service  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_upstream(body, async_req=True)
+        >>> thread = api.delete_gateway_service(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteUpstreamRequest body: (required)
-        :return: DeleteUpstreamResponse
+        :param DeleteGatewayServiceRequest body: (required)
+        :return: DeleteGatewayServiceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_upstream_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_gateway_service_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_upstream_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_gateway_service_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_upstream_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_upstream  # noqa: E501
+    def delete_gateway_service_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_gateway_service  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_upstream_with_http_info(body, async_req=True)
+        >>> thread = api.delete_gateway_service_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteUpstreamRequest body: (required)
-        :return: DeleteUpstreamResponse
+        :param DeleteGatewayServiceRequest body: (required)
+        :return: DeleteGatewayServiceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1244,14 +1438,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_upstream" % key
+                    " to method delete_gateway_service" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `delete_upstream`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_gateway_service`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1279,14 +1473,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteUpstream/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeleteGatewayService/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteUpstreamResponse',  # noqa: E501
+            response_type='DeleteGatewayServiceResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1294,38 +1488,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_upstream_source(self, body, **kwargs):  # noqa: E501
-        """delete_upstream_source  # noqa: E501
+    def delete_plugin_binding(self, body, **kwargs):  # noqa: E501
+        """delete_plugin_binding  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_upstream_source(body, async_req=True)
+        >>> thread = api.delete_plugin_binding(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteUpstreamSourceRequest body: (required)
-        :return: DeleteUpstreamSourceResponse
+        :param DeletePluginBindingRequest body: (required)
+        :return: DeletePluginBindingResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_upstream_source_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_plugin_binding_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_upstream_source_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_plugin_binding_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_upstream_source_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_upstream_source  # noqa: E501
+    def delete_plugin_binding_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_plugin_binding  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_upstream_source_with_http_info(body, async_req=True)
+        >>> thread = api.delete_plugin_binding_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteUpstreamSourceRequest body: (required)
-        :return: DeleteUpstreamSourceResponse
+        :param DeletePluginBindingRequest body: (required)
+        :return: DeletePluginBindingResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1341,14 +1535,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_upstream_source" % key
+                    " to method delete_plugin_binding" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `delete_upstream_source`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_plugin_binding`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1376,14 +1570,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteUpstreamSource/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeletePluginBinding/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteUpstreamSourceResponse',  # noqa: E501
+            response_type='DeletePluginBindingResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1391,38 +1585,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_consumer(self, body, **kwargs):  # noqa: E501
-        """get_consumer  # noqa: E501
+    def delete_upstream(self, body, **kwargs):  # noqa: E501
+        """delete_upstream  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_consumer(body, async_req=True)
+        >>> thread = api.delete_upstream(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetConsumerRequest body: (required)
-        :return: GetConsumerResponse
+        :param DeleteUpstreamRequest body: (required)
+        :return: DeleteUpstreamResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.get_consumer_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_upstream_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.get_consumer_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_upstream_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def get_consumer_with_http_info(self, body, **kwargs):  # noqa: E501
-        """get_consumer  # noqa: E501
+    def delete_upstream_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_upstream  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_consumer_with_http_info(body, async_req=True)
+        >>> thread = api.delete_upstream_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetConsumerRequest body: (required)
-        :return: GetConsumerResponse
+        :param DeleteUpstreamRequest body: (required)
+        :return: DeleteUpstreamResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1438,14 +1632,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_consumer" % key
+                    " to method delete_upstream" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `get_consumer`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_upstream`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1473,14 +1667,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GetConsumer/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeleteUpstream/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GetConsumerResponse',  # noqa: E501
+            response_type='DeleteUpstreamResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1488,38 +1682,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_gateway(self, body, **kwargs):  # noqa: E501
-        """get_gateway  # noqa: E501
+    def delete_upstream_source(self, body, **kwargs):  # noqa: E501
+        """delete_upstream_source  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_gateway(body, async_req=True)
+        >>> thread = api.delete_upstream_source(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetGatewayRequest body: (required)
-        :return: GetGatewayResponse
+        :param DeleteUpstreamSourceRequest body: (required)
+        :return: DeleteUpstreamSourceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.get_gateway_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_upstream_source_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.get_gateway_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_upstream_source_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def get_gateway_with_http_info(self, body, **kwargs):  # noqa: E501
-        """get_gateway  # noqa: E501
+    def delete_upstream_source_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_upstream_source  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_gateway_with_http_info(body, async_req=True)
+        >>> thread = api.delete_upstream_source_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetGatewayRequest body: (required)
-        :return: GetGatewayResponse
+        :param DeleteUpstreamSourceRequest body: (required)
+        :return: DeleteUpstreamSourceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1535,14 +1729,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_gateway" % key
+                    " to method delete_upstream_source" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `get_gateway`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_upstream_source`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1570,14 +1764,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GetGateway/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeleteUpstreamSource/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GetGatewayResponse',  # noqa: E501
+            response_type='DeleteUpstreamSourceResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1585,38 +1779,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_gateway_service(self, body, **kwargs):  # noqa: E501
-        """get_gateway_service  # noqa: E501
+    def delete_upstream_version(self, body, **kwargs):  # noqa: E501
+        """delete_upstream_version  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_gateway_service(body, async_req=True)
+        >>> thread = api.delete_upstream_version(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetGatewayServiceRequest body: (required)
-        :return: GetGatewayServiceResponse
+        :param DeleteUpstreamVersionRequest body: (required)
+        :return: DeleteUpstreamVersionResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.get_gateway_service_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_upstream_version_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.get_gateway_service_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_upstream_version_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def get_gateway_service_with_http_info(self, body, **kwargs):  # noqa: E501
-        """get_gateway_service  # noqa: E501
+    def delete_upstream_version_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_upstream_version  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_gateway_service_with_http_info(body, async_req=True)
+        >>> thread = api.delete_upstream_version_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetGatewayServiceRequest body: (required)
-        :return: GetGatewayServiceResponse
+        :param DeleteUpstreamVersionRequest body: (required)
+        :return: DeleteUpstreamVersionResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1632,14 +1826,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_gateway_service" % key
+                    " to method delete_upstream_version" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `get_gateway_service`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_upstream_version`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1667,14 +1861,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GetGatewayService/2021-03-03/apig/post/application_json/', 'POST',
+            '/DeleteUpstreamVersion/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GetGatewayServiceResponse',  # noqa: E501
+            response_type='DeleteUpstreamVersionResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1682,38 +1876,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_plugin_binding(self, body, **kwargs):  # noqa: E501
-        """get_plugin_binding  # noqa: E501
+    def detach_gateway_lb(self, body, **kwargs):  # noqa: E501
+        """detach_gateway_lb  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_plugin_binding(body, async_req=True)
+        >>> thread = api.detach_gateway_lb(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetPluginBindingRequest body: (required)
-        :return: GetPluginBindingResponse
+        :param DetachGatewayLBRequest body: (required)
+        :return: DetachGatewayLBResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.get_plugin_binding_with_http_info(body, **kwargs)  # noqa: E501
+            return self.detach_gateway_lb_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.get_plugin_binding_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.detach_gateway_lb_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def get_plugin_binding_with_http_info(self, body, **kwargs):  # noqa: E501
-        """get_plugin_binding  # noqa: E501
+    def detach_gateway_lb_with_http_info(self, body, **kwargs):  # noqa: E501
+        """detach_gateway_lb  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_plugin_binding_with_http_info(body, async_req=True)
+        >>> thread = api.detach_gateway_lb_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetPluginBindingRequest body: (required)
-        :return: GetPluginBindingResponse
+        :param DetachGatewayLBRequest body: (required)
+        :return: DetachGatewayLBResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1729,14 +1923,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_plugin_binding" % key
+                    " to method detach_gateway_lb" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `get_plugin_binding`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `detach_gateway_lb`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1764,14 +1958,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GetPluginBinding/2021-03-03/apig/post/application_json/', 'POST',
+            '/DetachGatewayLB/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GetPluginBindingResponse',  # noqa: E501
+            response_type='DetachGatewayLBResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1779,38 +1973,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_upstream(self, body, **kwargs):  # noqa: E501
-        """get_upstream  # noqa: E501
+    def get_consumer(self, body, **kwargs):  # noqa: E501
+        """get_consumer  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_upstream(body, async_req=True)
+        >>> thread = api.get_consumer(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetUpstreamRequest body: (required)
-        :return: GetUpstreamResponse
+        :param GetConsumerRequest body: (required)
+        :return: GetConsumerResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.get_upstream_with_http_info(body, **kwargs)  # noqa: E501
+            return self.get_consumer_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.get_upstream_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.get_consumer_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def get_upstream_with_http_info(self, body, **kwargs):  # noqa: E501
-        """get_upstream  # noqa: E501
+    def get_consumer_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_consumer  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_upstream_with_http_info(body, async_req=True)
+        >>> thread = api.get_consumer_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetUpstreamRequest body: (required)
-        :return: GetUpstreamResponse
+        :param GetConsumerRequest body: (required)
+        :return: GetConsumerResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1826,14 +2020,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_upstream" % key
+                    " to method get_consumer" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `get_upstream`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_consumer`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1861,14 +2055,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GetUpstream/2021-03-03/apig/post/application_json/', 'POST',
+            '/GetConsumer/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GetUpstreamResponse',  # noqa: E501
+            response_type='GetConsumerResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1876,38 +2070,38 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_upstream_source(self, body, **kwargs):  # noqa: E501
-        """get_upstream_source  # noqa: E501
+    def get_custom_domain(self, body, **kwargs):  # noqa: E501
+        """get_custom_domain  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_upstream_source(body, async_req=True)
+        >>> thread = api.get_custom_domain(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetUpstreamSourceRequest body: (required)
-        :return: GetUpstreamSourceResponse
+        :param GetCustomDomainRequest body: (required)
+        :return: GetCustomDomainResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.get_upstream_source_with_http_info(body, **kwargs)  # noqa: E501
+            return self.get_custom_domain_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.get_upstream_source_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.get_custom_domain_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def get_upstream_source_with_http_info(self, body, **kwargs):  # noqa: E501
-        """get_upstream_source  # noqa: E501
+    def get_custom_domain_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_custom_domain  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_upstream_source_with_http_info(body, async_req=True)
+        >>> thread = api.get_custom_domain_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetUpstreamSourceRequest body: (required)
-        :return: GetUpstreamSourceResponse
+        :param GetCustomDomainRequest body: (required)
+        :return: GetCustomDomainResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1923,14 +2117,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_upstream_source" % key
+                    " to method get_custom_domain" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `get_upstream_source`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_custom_domain`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1958,14 +2152,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GetUpstreamSource/2021-03-03/apig/post/application_json/', 'POST',
+            '/GetCustomDomain/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GetUpstreamSourceResponse',  # noqa: E501
+            response_type='GetCustomDomainResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1973,25 +2167,607 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_consumer_credentials(self, body, **kwargs):  # noqa: E501
-        """list_consumer_credentials  # noqa: E501
+    def get_gateway(self, body, **kwargs):  # noqa: E501
+        """get_gateway  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_consumer_credentials(body, async_req=True)
+        >>> thread = api.get_gateway(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListConsumerCredentialsRequest body: (required)
-        :return: ListConsumerCredentialsResponse
+        :param GetGatewayRequest body: (required)
+        :return: GetGatewayResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_consumer_credentials_with_http_info(body, **kwargs)  # noqa: E501
+            return self.get_gateway_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_consumer_credentials_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.get_gateway_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def get_gateway_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_gateway  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_gateway_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetGatewayRequest body: (required)
+        :return: GetGatewayResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_gateway" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_gateway`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GetGateway/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GetGatewayResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def get_gateway_service(self, body, **kwargs):  # noqa: E501
+        """get_gateway_service  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_gateway_service(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetGatewayServiceRequest body: (required)
+        :return: GetGatewayServiceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.get_gateway_service_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.get_gateway_service_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def get_gateway_service_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_gateway_service  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_gateway_service_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetGatewayServiceRequest body: (required)
+        :return: GetGatewayServiceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_gateway_service" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_gateway_service`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GetGatewayService/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GetGatewayServiceResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def get_jwt_token(self, body, **kwargs):  # noqa: E501
+        """get_jwt_token  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_jwt_token(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetJwtTokenRequest body: (required)
+        :return: GetJwtTokenResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.get_jwt_token_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.get_jwt_token_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def get_jwt_token_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_jwt_token  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_jwt_token_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetJwtTokenRequest body: (required)
+        :return: GetJwtTokenResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_jwt_token" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_jwt_token`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GetJwtToken/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GetJwtTokenResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def get_plugin_binding(self, body, **kwargs):  # noqa: E501
+        """get_plugin_binding  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_plugin_binding(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetPluginBindingRequest body: (required)
+        :return: GetPluginBindingResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.get_plugin_binding_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.get_plugin_binding_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def get_plugin_binding_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_plugin_binding  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_plugin_binding_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetPluginBindingRequest body: (required)
+        :return: GetPluginBindingResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_plugin_binding" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_plugin_binding`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GetPluginBinding/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GetPluginBindingResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def get_upstream(self, body, **kwargs):  # noqa: E501
+        """get_upstream  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_upstream(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetUpstreamRequest body: (required)
+        :return: GetUpstreamResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.get_upstream_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.get_upstream_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def get_upstream_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_upstream  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_upstream_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetUpstreamRequest body: (required)
+        :return: GetUpstreamResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_upstream" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_upstream`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GetUpstream/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GetUpstreamResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def get_upstream_source(self, body, **kwargs):  # noqa: E501
+        """get_upstream_source  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_upstream_source(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetUpstreamSourceRequest body: (required)
+        :return: GetUpstreamSourceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.get_upstream_source_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.get_upstream_source_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def get_upstream_source_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_upstream_source  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_upstream_source_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetUpstreamSourceRequest body: (required)
+        :return: GetUpstreamSourceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_upstream_source" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_upstream_source`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GetUpstreamSource/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GetUpstreamSourceResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_consumer_credentials(self, body, **kwargs):  # noqa: E501
+        """list_consumer_credentials  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_consumer_credentials(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListConsumerCredentialsRequest body: (required)
+        :return: ListConsumerCredentialsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_consumer_credentials_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_consumer_credentials_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
     def list_consumer_credentials_with_http_info(self, body, **kwargs):  # noqa: E501
@@ -2079,29 +2855,223 @@ class APIGApi(object):
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListConsumersRequest body: (required)
-        :return: ListConsumersResponse
+        :param ListConsumersRequest body: (required)
+        :return: ListConsumersResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_consumers_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_consumers_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_consumers_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_consumers  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_consumers_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListConsumersRequest body: (required)
+        :return: ListConsumersResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method list_consumers" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_consumers`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListConsumers/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListConsumersResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_custom_domains(self, body, **kwargs):  # noqa: E501
+        """list_custom_domains  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_custom_domains(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListCustomDomainsRequest body: (required)
+        :return: ListCustomDomainsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_custom_domains_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_custom_domains_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_custom_domains_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_custom_domains  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_custom_domains_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListCustomDomainsRequest body: (required)
+        :return: ListCustomDomainsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method list_custom_domains" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_custom_domains`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListCustomDomains/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListCustomDomainsResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_gateway_lbs(self, body, **kwargs):  # noqa: E501
+        """list_gateway_lbs  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_gateway_lbs(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListGatewayLBsRequest body: (required)
+        :return: ListGatewayLBsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_consumers_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_gateway_lbs_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_consumers_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_gateway_lbs_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_consumers_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_consumers  # noqa: E501
+    def list_gateway_lbs_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_gateway_lbs  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_consumers_with_http_info(body, async_req=True)
+        >>> thread = api.list_gateway_lbs_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListConsumersRequest body: (required)
-        :return: ListConsumersResponse
+        :param ListGatewayLBsRequest body: (required)
+        :return: ListGatewayLBsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2117,14 +3087,14 @@ class APIGApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_consumers" % key
+                    " to method list_gateway_lbs" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_consumers`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_gateway_lbs`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2152,14 +3122,14 @@ class APIGApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListConsumers/2021-03-03/apig/post/application_json/', 'POST',
+            '/ListGatewayLBs/2021-03-03/apig/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListConsumersResponse',  # noqa: E501
+            response_type='ListGatewayLBsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2749,6 +3719,103 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def update_custom_domain(self, body, **kwargs):  # noqa: E501
+        """update_custom_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_custom_domain(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateCustomDomainRequest body: (required)
+        :return: UpdateCustomDomainResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.update_custom_domain_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.update_custom_domain_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def update_custom_domain_with_http_info(self, body, **kwargs):  # noqa: E501
+        """update_custom_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_custom_domain_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateCustomDomainRequest body: (required)
+        :return: UpdateCustomDomainResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method update_custom_domain" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `update_custom_domain`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/UpdateCustomDomain/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UpdateCustomDomainResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def update_gateway(self, body, **kwargs):  # noqa: E501
         """update_gateway  # noqa: E501
 
@@ -3234,6 +4301,103 @@ class APIGApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def update_gateway_trace(self, body, **kwargs):  # noqa: E501
+        """update_gateway_trace  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_gateway_trace(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateGatewayTraceRequest body: (required)
+        :return: UpdateGatewayTraceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.update_gateway_trace_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.update_gateway_trace_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def update_gateway_trace_with_http_info(self, body, **kwargs):  # noqa: E501
+        """update_gateway_trace  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_gateway_trace_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateGatewayTraceRequest body: (required)
+        :return: UpdateGatewayTraceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method update_gateway_trace" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `update_gateway_trace`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/UpdateGatewayTrace/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UpdateGatewayTraceResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def update_plugin_binding(self, body, **kwargs):  # noqa: E501
         """update_plugin_binding  # noqa: E501
 
@@ -3524,3 +4688,100 @@ class APIGApi(object):
             _preload_content=params.get('_preload_content', True),
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
+
+    def update_upstream_version(self, body, **kwargs):  # noqa: E501
+        """update_upstream_version  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_upstream_version(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateUpstreamVersionRequest body: (required)
+        :return: UpdateUpstreamVersionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.update_upstream_version_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.update_upstream_version_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def update_upstream_version_with_http_info(self, body, **kwargs):  # noqa: E501
+        """update_upstream_version  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_upstream_version_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateUpstreamVersionRequest body: (required)
+        :return: UpdateUpstreamVersionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method update_upstream_version" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `update_upstream_version`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/UpdateUpstreamVersion/2021-03-03/apig/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UpdateUpstreamVersionResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)