volcengine-python-sdk 4.0.18__py2.py3-none-any.whl → 4.0.20__py2.py3-none-any.whl

volcenginesdkdirectconnect/api/directconnect_api.py

@@ -33,6 +33,103 @@ class DIRECTCONNECTApi(object):
             api_client = volcenginesdkcore.ApiClient()
         self.api_client = api_client
 
+    def allocate_direct_connect_virtual_interface(self, body, **kwargs):  # noqa: E501
+        """allocate_direct_connect_virtual_interface  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.allocate_direct_connect_virtual_interface(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AllocateDirectConnectVirtualInterfaceRequest body: (required)
+        :return: AllocateDirectConnectVirtualInterfaceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.allocate_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.allocate_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def allocate_direct_connect_virtual_interface_with_http_info(self, body, **kwargs):  # noqa: E501
+        """allocate_direct_connect_virtual_interface  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.allocate_direct_connect_virtual_interface_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AllocateDirectConnectVirtualInterfaceRequest body: (required)
+        :return: AllocateDirectConnectVirtualInterfaceResponse
+                 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 allocate_direct_connect_virtual_interface" % 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 `allocate_direct_connect_virtual_interface`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/AllocateDirectConnectVirtualInterface/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='AllocateDirectConnectVirtualInterfaceResponse',  # 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 apply_direct_connect_connection_loa(self, body, **kwargs):  # noqa: E501
         """apply_direct_connect_connection_loa  # noqa: E501
 
@@ -130,6 +227,103 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def confirm_direct_connect_virtual_interface(self, body, **kwargs):  # noqa: E501
+        """confirm_direct_connect_virtual_interface  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.confirm_direct_connect_virtual_interface(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ConfirmDirectConnectVirtualInterfaceRequest body: (required)
+        :return: ConfirmDirectConnectVirtualInterfaceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.confirm_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.confirm_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def confirm_direct_connect_virtual_interface_with_http_info(self, body, **kwargs):  # noqa: E501
+        """confirm_direct_connect_virtual_interface  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.confirm_direct_connect_virtual_interface_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ConfirmDirectConnectVirtualInterfaceRequest body: (required)
+        :return: ConfirmDirectConnectVirtualInterfaceResponse
+                 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 confirm_direct_connect_virtual_interface" % 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 `confirm_direct_connect_virtual_interface`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ConfirmDirectConnectVirtualInterface/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ConfirmDirectConnectVirtualInterfaceResponse',  # 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_bgp_peer(self, body, **kwargs):  # noqa: E501
         """create_bgp_peer  # noqa: E501
 
@@ -615,38 +809,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_direct_connect_virtual_interface(self, body, **kwargs):  # noqa: E501
-        """create_direct_connect_virtual_interface  # noqa: E501
+    def create_direct_connect_traffic_qos_policy(self, body, **kwargs):  # noqa: E501
+        """create_direct_connect_traffic_qos_policy  # 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_direct_connect_virtual_interface(body, async_req=True)
+        >>> thread = api.create_direct_connect_traffic_qos_policy(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateDirectConnectVirtualInterfaceRequest body: (required)
-        :return: CreateDirectConnectVirtualInterfaceResponse
+        :param CreateDirectConnectTrafficQosPolicyRequest body: (required)
+        :return: CreateDirectConnectTrafficQosPolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_direct_connect_traffic_qos_policy_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_direct_connect_traffic_qos_policy_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_direct_connect_virtual_interface_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_direct_connect_virtual_interface  # noqa: E501
+    def create_direct_connect_traffic_qos_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_direct_connect_traffic_qos_policy  # 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_direct_connect_virtual_interface_with_http_info(body, async_req=True)
+        >>> thread = api.create_direct_connect_traffic_qos_policy_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateDirectConnectVirtualInterfaceRequest body: (required)
-        :return: CreateDirectConnectVirtualInterfaceResponse
+        :param CreateDirectConnectTrafficQosPolicyRequest body: (required)
+        :return: CreateDirectConnectTrafficQosPolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -662,14 +856,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_direct_connect_virtual_interface" % key
+                    " to method create_direct_connect_traffic_qos_policy" % 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_direct_connect_virtual_interface`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_direct_connect_traffic_qos_policy`")  # noqa: E501
 
         collection_formats = {}
 
@@ -697,14 +891,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateDirectConnectVirtualInterface/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/CreateDirectConnectTrafficQosPolicy/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateDirectConnectVirtualInterfaceResponse',  # noqa: E501
+            response_type='CreateDirectConnectTrafficQosPolicyResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -712,38 +906,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_bgp_peer(self, body, **kwargs):  # noqa: E501
-        """delete_bgp_peer  # noqa: E501
+    def create_direct_connect_traffic_qos_queue(self, body, **kwargs):  # noqa: E501
+        """create_direct_connect_traffic_qos_queue  # 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_bgp_peer(body, async_req=True)
+        >>> thread = api.create_direct_connect_traffic_qos_queue(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteBgpPeerRequest body: (required)
-        :return: DeleteBgpPeerResponse
+        :param CreateDirectConnectTrafficQosQueueRequest body: (required)
+        :return: CreateDirectConnectTrafficQosQueueResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_bgp_peer_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_direct_connect_traffic_qos_queue_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_bgp_peer_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_direct_connect_traffic_qos_queue_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_bgp_peer_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_bgp_peer  # noqa: E501
+    def create_direct_connect_traffic_qos_queue_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_direct_connect_traffic_qos_queue  # 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_bgp_peer_with_http_info(body, async_req=True)
+        >>> thread = api.create_direct_connect_traffic_qos_queue_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteBgpPeerRequest body: (required)
-        :return: DeleteBgpPeerResponse
+        :param CreateDirectConnectTrafficQosQueueRequest body: (required)
+        :return: CreateDirectConnectTrafficQosQueueResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -759,14 +953,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_bgp_peer" % key
+                    " to method create_direct_connect_traffic_qos_queue" % 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_bgp_peer`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_direct_connect_traffic_qos_queue`")  # noqa: E501
 
         collection_formats = {}
 
@@ -794,14 +988,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteBgpPeer/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/CreateDirectConnectTrafficQosQueue/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteBgpPeerResponse',  # noqa: E501
+            response_type='CreateDirectConnectTrafficQosQueueResponse',  # 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 DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_direct_connect_connection(self, body, **kwargs):  # noqa: E501
-        """delete_direct_connect_connection  # noqa: E501
+    def create_direct_connect_traffic_qos_rule(self, body, **kwargs):  # noqa: E501
+        """create_direct_connect_traffic_qos_rule  # 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_direct_connect_connection(body, async_req=True)
+        >>> thread = api.create_direct_connect_traffic_qos_rule(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteDirectConnectConnectionRequest body: (required)
-        :return: DeleteDirectConnectConnectionResponse
+        :param CreateDirectConnectTrafficQosRuleRequest body: (required)
+        :return: CreateDirectConnectTrafficQosRuleResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_direct_connect_connection_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_direct_connect_traffic_qos_rule_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_direct_connect_connection_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_direct_connect_traffic_qos_rule_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_direct_connect_connection_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_direct_connect_connection  # noqa: E501
+    def create_direct_connect_traffic_qos_rule_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_direct_connect_traffic_qos_rule  # 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_direct_connect_connection_with_http_info(body, async_req=True)
+        >>> thread = api.create_direct_connect_traffic_qos_rule_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteDirectConnectConnectionRequest body: (required)
-        :return: DeleteDirectConnectConnectionResponse
+        :param CreateDirectConnectTrafficQosRuleRequest body: (required)
+        :return: CreateDirectConnectTrafficQosRuleResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -856,14 +1050,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_direct_connect_connection" % key
+                    " to method create_direct_connect_traffic_qos_rule" % 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_direct_connect_connection`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_direct_connect_traffic_qos_rule`")  # noqa: E501
 
         collection_formats = {}
 
@@ -891,14 +1085,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteDirectConnectConnection/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/CreateDirectConnectTrafficQosRule/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteDirectConnectConnectionResponse',  # noqa: E501
+            response_type='CreateDirectConnectTrafficQosRuleResponse',  # 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 DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_direct_connect_gateway(self, body, **kwargs):  # noqa: E501
-        """delete_direct_connect_gateway  # noqa: E501
+    def create_direct_connect_virtual_interface(self, body, **kwargs):  # noqa: E501
+        """create_direct_connect_virtual_interface  # 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_direct_connect_gateway(body, async_req=True)
+        >>> thread = api.create_direct_connect_virtual_interface(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteDirectConnectGatewayRequest body: (required)
-        :return: DeleteDirectConnectGatewayResponse
+        :param CreateDirectConnectVirtualInterfaceRequest body: (required)
+        :return: CreateDirectConnectVirtualInterfaceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_direct_connect_gateway_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_direct_connect_gateway_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_direct_connect_gateway_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_direct_connect_gateway  # noqa: E501
+    def create_direct_connect_virtual_interface_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_direct_connect_virtual_interface  # 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_direct_connect_gateway_with_http_info(body, async_req=True)
+        >>> thread = api.create_direct_connect_virtual_interface_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteDirectConnectGatewayRequest body: (required)
-        :return: DeleteDirectConnectGatewayResponse
+        :param CreateDirectConnectVirtualInterfaceRequest body: (required)
+        :return: CreateDirectConnectVirtualInterfaceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -953,14 +1147,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_direct_connect_gateway" % key
+                    " to method create_direct_connect_virtual_interface" % 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_direct_connect_gateway`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_direct_connect_virtual_interface`")  # noqa: E501
 
         collection_formats = {}
 
@@ -988,14 +1182,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteDirectConnectGateway/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/CreateDirectConnectVirtualInterface/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteDirectConnectGatewayResponse',  # noqa: E501
+            response_type='CreateDirectConnectVirtualInterfaceResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1003,25 +1197,316 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_direct_connect_gateway_route(self, body, **kwargs):  # noqa: E501
-        """delete_direct_connect_gateway_route  # noqa: E501
+    def delete_bgp_peer(self, body, **kwargs):  # noqa: E501
+        """delete_bgp_peer  # 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_direct_connect_gateway_route(body, async_req=True)
+        >>> thread = api.delete_bgp_peer(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteDirectConnectGatewayRouteRequest body: (required)
-        :return: DeleteDirectConnectGatewayRouteResponse
+        :param DeleteBgpPeerRequest body: (required)
+        :return: DeleteBgpPeerResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_direct_connect_gateway_route_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_bgp_peer_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_direct_connect_gateway_route_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_bgp_peer_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_bgp_peer_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_bgp_peer  # 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_bgp_peer_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteBgpPeerRequest body: (required)
+        :return: DeleteBgpPeerResponse
+                 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 delete_bgp_peer" % 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_bgp_peer`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteBgpPeer/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteBgpPeerResponse',  # 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 delete_direct_connect_connection(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_connection  # 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_direct_connect_connection(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectConnectionRequest body: (required)
+        :return: DeleteDirectConnectConnectionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_direct_connect_connection_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_direct_connect_connection_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_direct_connect_connection_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_connection  # 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_direct_connect_connection_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectConnectionRequest body: (required)
+        :return: DeleteDirectConnectConnectionResponse
+                 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 delete_direct_connect_connection" % 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_direct_connect_connection`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteDirectConnectConnection/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteDirectConnectConnectionResponse',  # 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 delete_direct_connect_gateway(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_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_direct_connect_gateway(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectGatewayRequest body: (required)
+        :return: DeleteDirectConnectGatewayResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_direct_connect_gateway_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_direct_connect_gateway_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_direct_connect_gateway_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_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_direct_connect_gateway_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectGatewayRequest body: (required)
+        :return: DeleteDirectConnectGatewayResponse
+                 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 delete_direct_connect_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_direct_connect_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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteDirectConnectGateway/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteDirectConnectGatewayResponse',  # 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 delete_direct_connect_gateway_route(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_gateway_route  # 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_direct_connect_gateway_route(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectGatewayRouteRequest body: (required)
+        :return: DeleteDirectConnectGatewayRouteResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_direct_connect_gateway_route_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_direct_connect_gateway_route_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
     def delete_direct_connect_gateway_route_with_http_info(self, body, **kwargs):  # noqa: E501
@@ -1029,12 +1514,1176 @@ class DIRECTCONNECTApi(object):
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_direct_connect_gateway_route_with_http_info(body, async_req=True)
+        >>> thread = api.delete_direct_connect_gateway_route_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectGatewayRouteRequest body: (required)
+        :return: DeleteDirectConnectGatewayRouteResponse
+                 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 delete_direct_connect_gateway_route" % 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_direct_connect_gateway_route`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteDirectConnectGatewayRoute/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteDirectConnectGatewayRouteResponse',  # 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 delete_direct_connect_traffic_qos_policy(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_traffic_qos_policy  # 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_direct_connect_traffic_qos_policy(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectTrafficQosPolicyRequest body: (required)
+        :return: DeleteDirectConnectTrafficQosPolicyResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_direct_connect_traffic_qos_policy_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_direct_connect_traffic_qos_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_direct_connect_traffic_qos_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_traffic_qos_policy  # 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_direct_connect_traffic_qos_policy_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectTrafficQosPolicyRequest body: (required)
+        :return: DeleteDirectConnectTrafficQosPolicyResponse
+                 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 delete_direct_connect_traffic_qos_policy" % 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_direct_connect_traffic_qos_policy`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteDirectConnectTrafficQosPolicy/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteDirectConnectTrafficQosPolicyResponse',  # 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 delete_direct_connect_traffic_qos_queue(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_traffic_qos_queue  # 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_direct_connect_traffic_qos_queue(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectTrafficQosQueueRequest body: (required)
+        :return: DeleteDirectConnectTrafficQosQueueResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_direct_connect_traffic_qos_queue_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_direct_connect_traffic_qos_queue_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_direct_connect_traffic_qos_queue_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_traffic_qos_queue  # 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_direct_connect_traffic_qos_queue_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectTrafficQosQueueRequest body: (required)
+        :return: DeleteDirectConnectTrafficQosQueueResponse
+                 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 delete_direct_connect_traffic_qos_queue" % 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_direct_connect_traffic_qos_queue`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteDirectConnectTrafficQosQueue/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteDirectConnectTrafficQosQueueResponse',  # 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 delete_direct_connect_traffic_qos_rule(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_traffic_qos_rule  # 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_direct_connect_traffic_qos_rule(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectTrafficQosRuleRequest body: (required)
+        :return: DeleteDirectConnectTrafficQosRuleResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_direct_connect_traffic_qos_rule_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_direct_connect_traffic_qos_rule_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_direct_connect_traffic_qos_rule_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_traffic_qos_rule  # 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_direct_connect_traffic_qos_rule_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectTrafficQosRuleRequest body: (required)
+        :return: DeleteDirectConnectTrafficQosRuleResponse
+                 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 delete_direct_connect_traffic_qos_rule" % 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_direct_connect_traffic_qos_rule`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteDirectConnectTrafficQosRule/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteDirectConnectTrafficQosRuleResponse',  # 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 delete_direct_connect_virtual_interface(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_virtual_interface  # 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_direct_connect_virtual_interface(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectVirtualInterfaceRequest body: (required)
+        :return: DeleteDirectConnectVirtualInterfaceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_direct_connect_virtual_interface_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_direct_connect_virtual_interface  # 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_direct_connect_virtual_interface_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteDirectConnectVirtualInterfaceRequest body: (required)
+        :return: DeleteDirectConnectVirtualInterfaceResponse
+                 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 delete_direct_connect_virtual_interface" % 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_direct_connect_virtual_interface`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteDirectConnectVirtualInterface/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteDirectConnectVirtualInterfaceResponse',  # 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 describe_bgp_peer_attributes(self, body, **kwargs):  # noqa: E501
+        """describe_bgp_peer_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_bgp_peer_attributes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeBgpPeerAttributesRequest body: (required)
+        :return: DescribeBgpPeerAttributesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_bgp_peer_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_bgp_peer_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_bgp_peer_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_bgp_peer_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_bgp_peer_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeBgpPeerAttributesRequest body: (required)
+        :return: DescribeBgpPeerAttributesResponse
+                 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 describe_bgp_peer_attributes" % 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 `describe_bgp_peer_attributes`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeBgpPeerAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeBgpPeerAttributesResponse',  # 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 describe_bgp_peers(self, body, **kwargs):  # noqa: E501
+        """describe_bgp_peers  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_bgp_peers(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeBgpPeersRequest body: (required)
+        :return: DescribeBgpPeersResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_bgp_peers_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_bgp_peers_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_bgp_peers_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_bgp_peers  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_bgp_peers_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeBgpPeersRequest body: (required)
+        :return: DescribeBgpPeersResponse
+                 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 describe_bgp_peers" % 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 `describe_bgp_peers`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeBgpPeers/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeBgpPeersResponse',  # 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 describe_direct_connect_access_points(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_access_points  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_access_points(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectAccessPointsRequest body: (required)
+        :return: DescribeDirectConnectAccessPointsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_direct_connect_access_points_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_direct_connect_access_points_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_direct_connect_access_points_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_access_points  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_access_points_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectAccessPointsRequest body: (required)
+        :return: DescribeDirectConnectAccessPointsResponse
+                 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 describe_direct_connect_access_points" % 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 `describe_direct_connect_access_points`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeDirectConnectAccessPoints/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeDirectConnectAccessPointsResponse',  # 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 describe_direct_connect_connection_attributes(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_connection_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_connection_attributes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectConnectionAttributesRequest body: (required)
+        :return: DescribeDirectConnectConnectionAttributesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_direct_connect_connection_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_direct_connect_connection_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_direct_connect_connection_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_connection_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_connection_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectConnectionAttributesRequest body: (required)
+        :return: DescribeDirectConnectConnectionAttributesResponse
+                 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 describe_direct_connect_connection_attributes" % 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 `describe_direct_connect_connection_attributes`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeDirectConnectConnectionAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeDirectConnectConnectionAttributesResponse',  # 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 describe_direct_connect_connection_loa_attributes(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_connection_loa_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_connection_loa_attributes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectConnectionLoaAttributesRequest body: (required)
+        :return: DescribeDirectConnectConnectionLoaAttributesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_direct_connect_connection_loa_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_direct_connect_connection_loa_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_direct_connect_connection_loa_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_connection_loa_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_connection_loa_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectConnectionLoaAttributesRequest body: (required)
+        :return: DescribeDirectConnectConnectionLoaAttributesResponse
+                 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 describe_direct_connect_connection_loa_attributes" % 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 `describe_direct_connect_connection_loa_attributes`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeDirectConnectConnectionLoaAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeDirectConnectConnectionLoaAttributesResponse',  # 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 describe_direct_connect_connections(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_connections  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_connections(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectConnectionsRequest body: (required)
+        :return: DescribeDirectConnectConnectionsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_direct_connect_connections_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_direct_connect_connections_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_direct_connect_connections_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_connections  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_connections_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectConnectionsRequest body: (required)
+        :return: DescribeDirectConnectConnectionsResponse
+                 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 describe_direct_connect_connections" % 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 `describe_direct_connect_connections`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeDirectConnectConnections/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeDirectConnectConnectionsResponse',  # 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 describe_direct_connect_gateway_attributes(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_gateway_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_gateway_attributes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectGatewayAttributesRequest body: (required)
+        :return: DescribeDirectConnectGatewayAttributesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_direct_connect_gateway_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_direct_connect_gateway_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_direct_connect_gateway_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_gateway_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_gateway_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectGatewayAttributesRequest body: (required)
+        :return: DescribeDirectConnectGatewayAttributesResponse
+                 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 describe_direct_connect_gateway_attributes" % 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 `describe_direct_connect_gateway_attributes`")  # 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
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeDirectConnectGatewayAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeDirectConnectGatewayAttributesResponse',  # 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 describe_direct_connect_gateway_route_attributes(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_gateway_route_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_gateway_route_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteDirectConnectGatewayRouteRequest body: (required)
-        :return: DeleteDirectConnectGatewayRouteResponse
+        :param DescribeDirectConnectGatewayRouteAttributesRequest body: (required)
+        :return: DescribeDirectConnectGatewayRouteAttributesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_direct_connect_gateway_route_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_direct_connect_gateway_route_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_direct_connect_gateway_route_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_gateway_route_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe_direct_connect_gateway_route_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDirectConnectGatewayRouteAttributesRequest body: (required)
+        :return: DescribeDirectConnectGatewayRouteAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1050,14 +2699,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_direct_connect_gateway_route" % key
+                    " to method describe_direct_connect_gateway_route_attributes" % 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_direct_connect_gateway_route`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_direct_connect_gateway_route_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1085,14 +2734,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteDirectConnectGatewayRoute/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/DescribeDirectConnectGatewayRouteAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteDirectConnectGatewayRouteResponse',  # noqa: E501
+            response_type='DescribeDirectConnectGatewayRouteAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1100,38 +2749,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_direct_connect_virtual_interface(self, body, **kwargs):  # noqa: E501
-        """delete_direct_connect_virtual_interface  # noqa: E501
+    def describe_direct_connect_gateway_routes(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_gateway_routes  # 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_direct_connect_virtual_interface(body, async_req=True)
+        >>> thread = api.describe_direct_connect_gateway_routes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteDirectConnectVirtualInterfaceRequest body: (required)
-        :return: DeleteDirectConnectVirtualInterfaceResponse
+        :param DescribeDirectConnectGatewayRoutesRequest body: (required)
+        :return: DescribeDirectConnectGatewayRoutesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_direct_connect_gateway_routes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_direct_connect_virtual_interface_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_direct_connect_gateway_routes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_direct_connect_virtual_interface_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_direct_connect_virtual_interface  # noqa: E501
+    def describe_direct_connect_gateway_routes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_gateway_routes  # 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_direct_connect_virtual_interface_with_http_info(body, async_req=True)
+        >>> thread = api.describe_direct_connect_gateway_routes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteDirectConnectVirtualInterfaceRequest body: (required)
-        :return: DeleteDirectConnectVirtualInterfaceResponse
+        :param DescribeDirectConnectGatewayRoutesRequest body: (required)
+        :return: DescribeDirectConnectGatewayRoutesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1147,14 +2796,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_direct_connect_virtual_interface" % key
+                    " to method describe_direct_connect_gateway_routes" % 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_direct_connect_virtual_interface`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_direct_connect_gateway_routes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1182,14 +2831,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteDirectConnectVirtualInterface/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/DescribeDirectConnectGatewayRoutes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteDirectConnectVirtualInterfaceResponse',  # noqa: E501
+            response_type='DescribeDirectConnectGatewayRoutesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1197,38 +2846,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_bgp_peer_attributes(self, body, **kwargs):  # noqa: E501
-        """describe_bgp_peer_attributes  # noqa: E501
+    def describe_direct_connect_gateways(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_gateways  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_bgp_peer_attributes(body, async_req=True)
+        >>> thread = api.describe_direct_connect_gateways(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeBgpPeerAttributesRequest body: (required)
-        :return: DescribeBgpPeerAttributesResponse
+        :param DescribeDirectConnectGatewaysRequest body: (required)
+        :return: DescribeDirectConnectGatewaysResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_bgp_peer_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_direct_connect_gateways_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_bgp_peer_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_direct_connect_gateways_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_bgp_peer_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_bgp_peer_attributes  # noqa: E501
+    def describe_direct_connect_gateways_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_gateways  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_bgp_peer_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.describe_direct_connect_gateways_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeBgpPeerAttributesRequest body: (required)
-        :return: DescribeBgpPeerAttributesResponse
+        :param DescribeDirectConnectGatewaysRequest body: (required)
+        :return: DescribeDirectConnectGatewaysResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1244,14 +2893,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_bgp_peer_attributes" % key
+                    " to method describe_direct_connect_gateways" % 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 `describe_bgp_peer_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_direct_connect_gateways`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1279,14 +2928,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeBgpPeerAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/DescribeDirectConnectGateways/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeBgpPeerAttributesResponse',  # noqa: E501
+            response_type='DescribeDirectConnectGatewaysResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1294,38 +2943,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_bgp_peers(self, body, **kwargs):  # noqa: E501
-        """describe_bgp_peers  # noqa: E501
+    def describe_direct_connect_traffic_qos_policies(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_traffic_qos_policies  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_bgp_peers(body, async_req=True)
+        >>> thread = api.describe_direct_connect_traffic_qos_policies(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeBgpPeersRequest body: (required)
-        :return: DescribeBgpPeersResponse
+        :param DescribeDirectConnectTrafficQosPoliciesRequest body: (required)
+        :return: DescribeDirectConnectTrafficQosPoliciesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_bgp_peers_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_direct_connect_traffic_qos_policies_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_bgp_peers_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_direct_connect_traffic_qos_policies_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_bgp_peers_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_bgp_peers  # noqa: E501
+    def describe_direct_connect_traffic_qos_policies_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_traffic_qos_policies  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_bgp_peers_with_http_info(body, async_req=True)
+        >>> thread = api.describe_direct_connect_traffic_qos_policies_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeBgpPeersRequest body: (required)
-        :return: DescribeBgpPeersResponse
+        :param DescribeDirectConnectTrafficQosPoliciesRequest body: (required)
+        :return: DescribeDirectConnectTrafficQosPoliciesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1341,14 +2990,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_bgp_peers" % key
+                    " to method describe_direct_connect_traffic_qos_policies" % 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 `describe_bgp_peers`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_direct_connect_traffic_qos_policies`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1376,14 +3025,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeBgpPeers/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/DescribeDirectConnectTrafficQosPolicies/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeBgpPeersResponse',  # noqa: E501
+            response_type='DescribeDirectConnectTrafficQosPoliciesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1391,38 +3040,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_access_points(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_access_points  # noqa: E501
+    def describe_direct_connect_traffic_qos_queues(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_traffic_qos_queues  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_access_points(body, async_req=True)
+        >>> thread = api.describe_direct_connect_traffic_qos_queues(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectAccessPointsRequest body: (required)
-        :return: DescribeDirectConnectAccessPointsResponse
+        :param DescribeDirectConnectTrafficQosQueuesRequest body: (required)
+        :return: DescribeDirectConnectTrafficQosQueuesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_access_points_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_direct_connect_traffic_qos_queues_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_access_points_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_direct_connect_traffic_qos_queues_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_access_points_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_access_points  # noqa: E501
+    def describe_direct_connect_traffic_qos_queues_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_traffic_qos_queues  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_access_points_with_http_info(body, async_req=True)
+        >>> thread = api.describe_direct_connect_traffic_qos_queues_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectAccessPointsRequest body: (required)
-        :return: DescribeDirectConnectAccessPointsResponse
+        :param DescribeDirectConnectTrafficQosQueuesRequest body: (required)
+        :return: DescribeDirectConnectTrafficQosQueuesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1438,14 +3087,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_access_points" % key
+                    " to method describe_direct_connect_traffic_qos_queues" % 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 `describe_direct_connect_access_points`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_direct_connect_traffic_qos_queues`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1473,14 +3122,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectAccessPoints/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/DescribeDirectConnectTrafficQosQueues/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectAccessPointsResponse',  # noqa: E501
+            response_type='DescribeDirectConnectTrafficQosQueuesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1488,38 +3137,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_connection_attributes(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_connection_attributes  # noqa: E501
+    def describe_direct_connect_traffic_qos_rules(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_traffic_qos_rules  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_connection_attributes(body, async_req=True)
+        >>> thread = api.describe_direct_connect_traffic_qos_rules(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectConnectionAttributesRequest body: (required)
-        :return: DescribeDirectConnectConnectionAttributesResponse
+        :param DescribeDirectConnectTrafficQosRulesRequest body: (required)
+        :return: DescribeDirectConnectTrafficQosRulesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_connection_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_direct_connect_traffic_qos_rules_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_connection_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_direct_connect_traffic_qos_rules_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_connection_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_connection_attributes  # noqa: E501
+    def describe_direct_connect_traffic_qos_rules_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_traffic_qos_rules  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_connection_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.describe_direct_connect_traffic_qos_rules_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectConnectionAttributesRequest body: (required)
-        :return: DescribeDirectConnectConnectionAttributesResponse
+        :param DescribeDirectConnectTrafficQosRulesRequest body: (required)
+        :return: DescribeDirectConnectTrafficQosRulesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1535,14 +3184,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_connection_attributes" % key
+                    " to method describe_direct_connect_traffic_qos_rules" % 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 `describe_direct_connect_connection_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_direct_connect_traffic_qos_rules`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1570,14 +3219,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectConnectionAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/DescribeDirectConnectTrafficQosRules/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectConnectionAttributesResponse',  # noqa: E501
+            response_type='DescribeDirectConnectTrafficQosRulesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1585,38 +3234,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_connection_loa_attributes(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_connection_loa_attributes  # noqa: E501
+    def describe_direct_connect_virtual_interface_attributes(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_virtual_interface_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_connection_loa_attributes(body, async_req=True)
+        >>> thread = api.describe_direct_connect_virtual_interface_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectConnectionLoaAttributesRequest body: (required)
-        :return: DescribeDirectConnectConnectionLoaAttributesResponse
+        :param DescribeDirectConnectVirtualInterfaceAttributesRequest body: (required)
+        :return: DescribeDirectConnectVirtualInterfaceAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_connection_loa_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_direct_connect_virtual_interface_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_connection_loa_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_direct_connect_virtual_interface_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_connection_loa_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_connection_loa_attributes  # noqa: E501
+    def describe_direct_connect_virtual_interface_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_virtual_interface_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_connection_loa_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.describe_direct_connect_virtual_interface_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectConnectionLoaAttributesRequest body: (required)
-        :return: DescribeDirectConnectConnectionLoaAttributesResponse
+        :param DescribeDirectConnectVirtualInterfaceAttributesRequest body: (required)
+        :return: DescribeDirectConnectVirtualInterfaceAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1632,14 +3281,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_connection_loa_attributes" % key
+                    " to method describe_direct_connect_virtual_interface_attributes" % 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 `describe_direct_connect_connection_loa_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_direct_connect_virtual_interface_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1667,14 +3316,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectConnectionLoaAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/DescribeDirectConnectVirtualInterfaceAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectConnectionLoaAttributesResponse',  # noqa: E501
+            response_type='DescribeDirectConnectVirtualInterfaceAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1682,38 +3331,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_connections(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_connections  # noqa: E501
+    def describe_direct_connect_virtual_interfaces(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_virtual_interfaces  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_connections(body, async_req=True)
+        >>> thread = api.describe_direct_connect_virtual_interfaces(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectConnectionsRequest body: (required)
-        :return: DescribeDirectConnectConnectionsResponse
+        :param DescribeDirectConnectVirtualInterfacesRequest body: (required)
+        :return: DescribeDirectConnectVirtualInterfacesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_connections_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_direct_connect_virtual_interfaces_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_connections_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_direct_connect_virtual_interfaces_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_connections_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_connections  # noqa: E501
+    def describe_direct_connect_virtual_interfaces_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_direct_connect_virtual_interfaces  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_connections_with_http_info(body, async_req=True)
+        >>> thread = api.describe_direct_connect_virtual_interfaces_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectConnectionsRequest body: (required)
-        :return: DescribeDirectConnectConnectionsResponse
+        :param DescribeDirectConnectVirtualInterfacesRequest body: (required)
+        :return: DescribeDirectConnectVirtualInterfacesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1729,14 +3378,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_connections" % key
+                    " to method describe_direct_connect_virtual_interfaces" % 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 `describe_direct_connect_connections`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_direct_connect_virtual_interfaces`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1764,14 +3413,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectConnections/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/DescribeDirectConnectVirtualInterfaces/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectConnectionsResponse',  # noqa: E501
+            response_type='DescribeDirectConnectVirtualInterfacesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1779,38 +3428,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_gateway_attributes(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_gateway_attributes  # noqa: E501
+    def list_tags_for_resources(self, body, **kwargs):  # noqa: E501
+        """list_tags_for_resources  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_gateway_attributes(body, async_req=True)
+        >>> thread = api.list_tags_for_resources(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectGatewayAttributesRequest body: (required)
-        :return: DescribeDirectConnectGatewayAttributesResponse
+        :param ListTagsForResourcesRequest body: (required)
+        :return: ListTagsForResourcesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_gateway_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_tags_for_resources_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_gateway_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_tags_for_resources_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_gateway_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_gateway_attributes  # noqa: E501
+    def list_tags_for_resources_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_tags_for_resources  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_gateway_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.list_tags_for_resources_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectGatewayAttributesRequest body: (required)
-        :return: DescribeDirectConnectGatewayAttributesResponse
+        :param ListTagsForResourcesRequest body: (required)
+        :return: ListTagsForResourcesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1826,14 +3475,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_gateway_attributes" % key
+                    " to method list_tags_for_resources" % 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 `describe_direct_connect_gateway_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_tags_for_resources`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1861,14 +3510,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectGatewayAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ListTagsForResources/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectGatewayAttributesResponse',  # noqa: E501
+            response_type='ListTagsForResourcesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1876,38 +3525,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_gateway_route_attributes(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_gateway_route_attributes  # noqa: E501
+    def modify_bgp_peer_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_bgp_peer_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_gateway_route_attributes(body, async_req=True)
+        >>> thread = api.modify_bgp_peer_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectGatewayRouteAttributesRequest body: (required)
-        :return: DescribeDirectConnectGatewayRouteAttributesResponse
+        :param ModifyBgpPeerAttributesRequest body: (required)
+        :return: ModifyBgpPeerAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_gateway_route_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_bgp_peer_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_gateway_route_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_bgp_peer_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_gateway_route_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_gateway_route_attributes  # noqa: E501
+    def modify_bgp_peer_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_bgp_peer_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_gateway_route_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.modify_bgp_peer_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectGatewayRouteAttributesRequest body: (required)
-        :return: DescribeDirectConnectGatewayRouteAttributesResponse
+        :param ModifyBgpPeerAttributesRequest body: (required)
+        :return: ModifyBgpPeerAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1923,14 +3572,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_gateway_route_attributes" % key
+                    " to method modify_bgp_peer_attributes" % 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 `describe_direct_connect_gateway_route_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_bgp_peer_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1958,14 +3607,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectGatewayRouteAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ModifyBgpPeerAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectGatewayRouteAttributesResponse',  # noqa: E501
+            response_type='ModifyBgpPeerAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1973,38 +3622,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_gateway_routes(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_gateway_routes  # noqa: E501
+    def modify_direct_connect_connection_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_connection_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_gateway_routes(body, async_req=True)
+        >>> thread = api.modify_direct_connect_connection_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectGatewayRoutesRequest body: (required)
-        :return: DescribeDirectConnectGatewayRoutesResponse
+        :param ModifyDirectConnectConnectionAttributesRequest body: (required)
+        :return: ModifyDirectConnectConnectionAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_gateway_routes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_direct_connect_connection_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_gateway_routes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_direct_connect_connection_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_gateway_routes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_gateway_routes  # noqa: E501
+    def modify_direct_connect_connection_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_connection_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_gateway_routes_with_http_info(body, async_req=True)
+        >>> thread = api.modify_direct_connect_connection_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectGatewayRoutesRequest body: (required)
-        :return: DescribeDirectConnectGatewayRoutesResponse
+        :param ModifyDirectConnectConnectionAttributesRequest body: (required)
+        :return: ModifyDirectConnectConnectionAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2020,14 +3669,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_gateway_routes" % key
+                    " to method modify_direct_connect_connection_attributes" % 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 `describe_direct_connect_gateway_routes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_direct_connect_connection_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2055,14 +3704,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectGatewayRoutes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ModifyDirectConnectConnectionAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectGatewayRoutesResponse',  # noqa: E501
+            response_type='ModifyDirectConnectConnectionAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2070,38 +3719,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_gateways(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_gateways  # noqa: E501
+    def modify_direct_connect_connection_loa_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_connection_loa_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_gateways(body, async_req=True)
+        >>> thread = api.modify_direct_connect_connection_loa_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectGatewaysRequest body: (required)
-        :return: DescribeDirectConnectGatewaysResponse
+        :param ModifyDirectConnectConnectionLoaAttributesRequest body: (required)
+        :return: ModifyDirectConnectConnectionLoaAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_gateways_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_direct_connect_connection_loa_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_gateways_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_direct_connect_connection_loa_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_gateways_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_gateways  # noqa: E501
+    def modify_direct_connect_connection_loa_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_connection_loa_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_gateways_with_http_info(body, async_req=True)
+        >>> thread = api.modify_direct_connect_connection_loa_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectGatewaysRequest body: (required)
-        :return: DescribeDirectConnectGatewaysResponse
+        :param ModifyDirectConnectConnectionLoaAttributesRequest body: (required)
+        :return: ModifyDirectConnectConnectionLoaAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2117,14 +3766,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_gateways" % key
+                    " to method modify_direct_connect_connection_loa_attributes" % 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 `describe_direct_connect_gateways`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_direct_connect_connection_loa_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2152,14 +3801,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectGateways/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ModifyDirectConnectConnectionLoaAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectGatewaysResponse',  # noqa: E501
+            response_type='ModifyDirectConnectConnectionLoaAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2167,38 +3816,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_virtual_interface_attributes(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_virtual_interface_attributes  # noqa: E501
+    def modify_direct_connect_gateway_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_gateway_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_virtual_interface_attributes(body, async_req=True)
+        >>> thread = api.modify_direct_connect_gateway_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectVirtualInterfaceAttributesRequest body: (required)
-        :return: DescribeDirectConnectVirtualInterfaceAttributesResponse
+        :param ModifyDirectConnectGatewayAttributesRequest body: (required)
+        :return: ModifyDirectConnectGatewayAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_virtual_interface_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_direct_connect_gateway_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_virtual_interface_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_direct_connect_gateway_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_virtual_interface_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_virtual_interface_attributes  # noqa: E501
+    def modify_direct_connect_gateway_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_gateway_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_virtual_interface_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.modify_direct_connect_gateway_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectVirtualInterfaceAttributesRequest body: (required)
-        :return: DescribeDirectConnectVirtualInterfaceAttributesResponse
+        :param ModifyDirectConnectGatewayAttributesRequest body: (required)
+        :return: ModifyDirectConnectGatewayAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2214,14 +3863,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_virtual_interface_attributes" % key
+                    " to method modify_direct_connect_gateway_attributes" % 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 `describe_direct_connect_virtual_interface_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_direct_connect_gateway_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2249,14 +3898,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectVirtualInterfaceAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ModifyDirectConnectGatewayAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectVirtualInterfaceAttributesResponse',  # noqa: E501
+            response_type='ModifyDirectConnectGatewayAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2264,38 +3913,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_direct_connect_virtual_interfaces(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_virtual_interfaces  # noqa: E501
+    def modify_direct_connect_traffic_qos_policy_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_traffic_qos_policy_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_virtual_interfaces(body, async_req=True)
+        >>> thread = api.modify_direct_connect_traffic_qos_policy_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectVirtualInterfacesRequest body: (required)
-        :return: DescribeDirectConnectVirtualInterfacesResponse
+        :param ModifyDirectConnectTrafficQosPolicyAttributesRequest body: (required)
+        :return: ModifyDirectConnectTrafficQosPolicyAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_direct_connect_virtual_interfaces_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_direct_connect_traffic_qos_policy_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_direct_connect_virtual_interfaces_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_direct_connect_traffic_qos_policy_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_direct_connect_virtual_interfaces_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_direct_connect_virtual_interfaces  # noqa: E501
+    def modify_direct_connect_traffic_qos_policy_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_traffic_qos_policy_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_direct_connect_virtual_interfaces_with_http_info(body, async_req=True)
+        >>> thread = api.modify_direct_connect_traffic_qos_policy_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDirectConnectVirtualInterfacesRequest body: (required)
-        :return: DescribeDirectConnectVirtualInterfacesResponse
+        :param ModifyDirectConnectTrafficQosPolicyAttributesRequest body: (required)
+        :return: ModifyDirectConnectTrafficQosPolicyAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2311,14 +3960,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_direct_connect_virtual_interfaces" % key
+                    " to method modify_direct_connect_traffic_qos_policy_attributes" % 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 `describe_direct_connect_virtual_interfaces`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_direct_connect_traffic_qos_policy_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2346,14 +3995,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDirectConnectVirtualInterfaces/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ModifyDirectConnectTrafficQosPolicyAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDirectConnectVirtualInterfacesResponse',  # noqa: E501
+            response_type='ModifyDirectConnectTrafficQosPolicyAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2361,38 +4010,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_bgp_peer_attributes(self, body, **kwargs):  # noqa: E501
-        """modify_bgp_peer_attributes  # noqa: E501
+    def modify_direct_connect_traffic_qos_queue_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_traffic_qos_queue_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_bgp_peer_attributes(body, async_req=True)
+        >>> thread = api.modify_direct_connect_traffic_qos_queue_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyBgpPeerAttributesRequest body: (required)
-        :return: ModifyBgpPeerAttributesResponse
+        :param ModifyDirectConnectTrafficQosQueueAttributesRequest body: (required)
+        :return: ModifyDirectConnectTrafficQosQueueAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_bgp_peer_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_direct_connect_traffic_qos_queue_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_bgp_peer_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_direct_connect_traffic_qos_queue_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_bgp_peer_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_bgp_peer_attributes  # noqa: E501
+    def modify_direct_connect_traffic_qos_queue_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_traffic_qos_queue_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_bgp_peer_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.modify_direct_connect_traffic_qos_queue_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyBgpPeerAttributesRequest body: (required)
-        :return: ModifyBgpPeerAttributesResponse
+        :param ModifyDirectConnectTrafficQosQueueAttributesRequest body: (required)
+        :return: ModifyDirectConnectTrafficQosQueueAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2408,14 +4057,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_bgp_peer_attributes" % key
+                    " to method modify_direct_connect_traffic_qos_queue_attributes" % 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 `modify_bgp_peer_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_direct_connect_traffic_qos_queue_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2443,14 +4092,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyBgpPeerAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ModifyDirectConnectTrafficQosQueueAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyBgpPeerAttributesResponse',  # noqa: E501
+            response_type='ModifyDirectConnectTrafficQosQueueAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2458,38 +4107,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_direct_connect_connection_attributes(self, body, **kwargs):  # noqa: E501
-        """modify_direct_connect_connection_attributes  # noqa: E501
+    def modify_direct_connect_traffic_qos_rule_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_traffic_qos_rule_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_direct_connect_connection_attributes(body, async_req=True)
+        >>> thread = api.modify_direct_connect_traffic_qos_rule_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDirectConnectConnectionAttributesRequest body: (required)
-        :return: ModifyDirectConnectConnectionAttributesResponse
+        :param ModifyDirectConnectTrafficQosRuleAttributesRequest body: (required)
+        :return: ModifyDirectConnectTrafficQosRuleAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_direct_connect_connection_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_direct_connect_traffic_qos_rule_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_direct_connect_connection_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_direct_connect_traffic_qos_rule_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_direct_connect_connection_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_direct_connect_connection_attributes  # noqa: E501
+    def modify_direct_connect_traffic_qos_rule_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_traffic_qos_rule_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_direct_connect_connection_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.modify_direct_connect_traffic_qos_rule_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDirectConnectConnectionAttributesRequest body: (required)
-        :return: ModifyDirectConnectConnectionAttributesResponse
+        :param ModifyDirectConnectTrafficQosRuleAttributesRequest body: (required)
+        :return: ModifyDirectConnectTrafficQosRuleAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2505,14 +4154,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_direct_connect_connection_attributes" % key
+                    " to method modify_direct_connect_traffic_qos_rule_attributes" % 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 `modify_direct_connect_connection_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_direct_connect_traffic_qos_rule_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2540,14 +4189,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDirectConnectConnectionAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ModifyDirectConnectTrafficQosRuleAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDirectConnectConnectionAttributesResponse',  # noqa: E501
+            response_type='ModifyDirectConnectTrafficQosRuleAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2555,38 +4204,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_direct_connect_connection_loa_attributes(self, body, **kwargs):  # noqa: E501
-        """modify_direct_connect_connection_loa_attributes  # noqa: E501
+    def modify_direct_connect_virtual_interface_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_virtual_interface_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_direct_connect_connection_loa_attributes(body, async_req=True)
+        >>> thread = api.modify_direct_connect_virtual_interface_attributes(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDirectConnectConnectionLoaAttributesRequest body: (required)
-        :return: ModifyDirectConnectConnectionLoaAttributesResponse
+        :param ModifyDirectConnectVirtualInterfaceAttributesRequest body: (required)
+        :return: ModifyDirectConnectVirtualInterfaceAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_direct_connect_connection_loa_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_direct_connect_virtual_interface_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_direct_connect_connection_loa_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_direct_connect_virtual_interface_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_direct_connect_connection_loa_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_direct_connect_connection_loa_attributes  # noqa: E501
+    def modify_direct_connect_virtual_interface_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_direct_connect_virtual_interface_attributes  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_direct_connect_connection_loa_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.modify_direct_connect_virtual_interface_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDirectConnectConnectionLoaAttributesRequest body: (required)
-        :return: ModifyDirectConnectConnectionLoaAttributesResponse
+        :param ModifyDirectConnectVirtualInterfaceAttributesRequest body: (required)
+        :return: ModifyDirectConnectVirtualInterfaceAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2602,14 +4251,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_direct_connect_connection_loa_attributes" % key
+                    " to method modify_direct_connect_virtual_interface_attributes" % 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 `modify_direct_connect_connection_loa_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_direct_connect_virtual_interface_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2637,14 +4286,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDirectConnectConnectionLoaAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/ModifyDirectConnectVirtualInterfaceAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDirectConnectConnectionLoaAttributesResponse',  # noqa: E501
+            response_type='ModifyDirectConnectVirtualInterfaceAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2652,38 +4301,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_direct_connect_gateway_attributes(self, body, **kwargs):  # noqa: E501
-        """modify_direct_connect_gateway_attributes  # noqa: E501
+    def tag_resources(self, body, **kwargs):  # noqa: E501
+        """tag_resources  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_direct_connect_gateway_attributes(body, async_req=True)
+        >>> thread = api.tag_resources(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDirectConnectGatewayAttributesRequest body: (required)
-        :return: ModifyDirectConnectGatewayAttributesResponse
+        :param TagResourcesRequest body: (required)
+        :return: TagResourcesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_direct_connect_gateway_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.tag_resources_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_direct_connect_gateway_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.tag_resources_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_direct_connect_gateway_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_direct_connect_gateway_attributes  # noqa: E501
+    def tag_resources_with_http_info(self, body, **kwargs):  # noqa: E501
+        """tag_resources  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_direct_connect_gateway_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.tag_resources_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDirectConnectGatewayAttributesRequest body: (required)
-        :return: ModifyDirectConnectGatewayAttributesResponse
+        :param TagResourcesRequest body: (required)
+        :return: TagResourcesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2699,14 +4348,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_direct_connect_gateway_attributes" % key
+                    " to method tag_resources" % 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 `modify_direct_connect_gateway_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `tag_resources`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2734,14 +4383,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDirectConnectGatewayAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/TagResources/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDirectConnectGatewayAttributesResponse',  # noqa: E501
+            response_type='TagResourcesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2749,38 +4398,38 @@ class DIRECTCONNECTApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_direct_connect_virtual_interface_attributes(self, body, **kwargs):  # noqa: E501
-        """modify_direct_connect_virtual_interface_attributes  # noqa: E501
+    def untag_resources(self, body, **kwargs):  # noqa: E501
+        """untag_resources  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_direct_connect_virtual_interface_attributes(body, async_req=True)
+        >>> thread = api.untag_resources(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDirectConnectVirtualInterfaceAttributesRequest body: (required)
-        :return: ModifyDirectConnectVirtualInterfaceAttributesResponse
+        :param UntagResourcesRequest body: (required)
+        :return: UntagResourcesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_direct_connect_virtual_interface_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.untag_resources_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_direct_connect_virtual_interface_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.untag_resources_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_direct_connect_virtual_interface_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_direct_connect_virtual_interface_attributes  # noqa: E501
+    def untag_resources_with_http_info(self, body, **kwargs):  # noqa: E501
+        """untag_resources  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.modify_direct_connect_virtual_interface_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.untag_resources_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDirectConnectVirtualInterfaceAttributesRequest body: (required)
-        :return: ModifyDirectConnectVirtualInterfaceAttributesResponse
+        :param UntagResourcesRequest body: (required)
+        :return: UntagResourcesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2796,14 +4445,14 @@ class DIRECTCONNECTApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_direct_connect_virtual_interface_attributes" % key
+                    " to method untag_resources" % 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 `modify_direct_connect_virtual_interface_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `untag_resources`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2831,14 +4480,14 @@ class DIRECTCONNECTApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDirectConnectVirtualInterfaceAttributes/2020-04-01/directconnect/get/text_plain/', 'GET',
+            '/UntagResources/2020-04-01/directconnect/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDirectConnectVirtualInterfaceAttributesResponse',  # noqa: E501
+            response_type='UntagResourcesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),