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

volcenginesdktransitrouter/api/transitrouter_api.py

@@ -324,6 +324,103 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def associate_transit_router_multicast_domain(self, body, **kwargs):  # noqa: E501
+        """associate_transit_router_multicast_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.associate_transit_router_multicast_domain(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AssociateTransitRouterMulticastDomainRequest body: (required)
+        :return: AssociateTransitRouterMulticastDomainResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.associate_transit_router_multicast_domain_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.associate_transit_router_multicast_domain_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def associate_transit_router_multicast_domain_with_http_info(self, body, **kwargs):  # noqa: E501
+        """associate_transit_router_multicast_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.associate_transit_router_multicast_domain_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AssociateTransitRouterMulticastDomainRequest body: (required)
+        :return: AssociateTransitRouterMulticastDomainResponse
+                 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 associate_transit_router_multicast_domain" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `associate_transit_router_multicast_domain`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/AssociateTransitRouterMulticastDomain/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='AssociateTransitRouterMulticastDomainResponse',  # 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 associate_transit_router_route_policy_to_route_table(self, body, **kwargs):  # noqa: E501
         """associate_transit_router_route_policy_to_route_table  # noqa: E501
 
@@ -906,6 +1003,103 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def create_transit_router_flow_log(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_flow_log  # 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_transit_router_flow_log(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateTransitRouterFlowLogRequest body: (required)
+        :return: CreateTransitRouterFlowLogResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.create_transit_router_flow_log_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.create_transit_router_flow_log_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def create_transit_router_flow_log_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_flow_log  # 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_transit_router_flow_log_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateTransitRouterFlowLogRequest body: (required)
+        :return: CreateTransitRouterFlowLogResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method create_transit_router_flow_log" % 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_transit_router_flow_log`")  # 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(
+            '/CreateTransitRouterFlowLog/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='CreateTransitRouterFlowLogResponse',  # 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_transit_router_forward_policy_entry(self, body, **kwargs):  # noqa: E501
         """create_transit_router_forward_policy_entry  # noqa: E501
 
@@ -1197,38 +1391,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_peer_attachment(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_peer_attachment  # noqa: E501
+    def create_transit_router_multicast_domain(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_multicast_domain  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.create_transit_router_peer_attachment(body, async_req=True)
+        >>> thread = api.create_transit_router_multicast_domain(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterPeerAttachmentRequest body: (required)
-        :return: CreateTransitRouterPeerAttachmentResponse
+        :param CreateTransitRouterMulticastDomainRequest body: (required)
+        :return: CreateTransitRouterMulticastDomainResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_multicast_domain_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_multicast_domain_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_peer_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_peer_attachment  # noqa: E501
+    def create_transit_router_multicast_domain_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_multicast_domain  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.create_transit_router_peer_attachment_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_multicast_domain_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterPeerAttachmentRequest body: (required)
-        :return: CreateTransitRouterPeerAttachmentResponse
+        :param CreateTransitRouterMulticastDomainRequest body: (required)
+        :return: CreateTransitRouterMulticastDomainResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1244,14 +1438,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_peer_attachment" % key
+                    " to method create_transit_router_multicast_domain" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_peer_attachment`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_multicast_domain`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1279,14 +1473,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterPeerAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterMulticastDomain/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterPeerAttachmentResponse',  # noqa: E501
+            response_type='CreateTransitRouterMulticastDomainResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1294,38 +1488,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_route_entry(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_route_entry  # noqa: E501
+    def create_transit_router_multicast_group_member(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_multicast_group_member  # 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_transit_router_route_entry(body, async_req=True)
+        >>> thread = api.create_transit_router_multicast_group_member(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterRouteEntryRequest body: (required)
-        :return: CreateTransitRouterRouteEntryResponse
+        :param CreateTransitRouterMulticastGroupMemberRequest body: (required)
+        :return: CreateTransitRouterMulticastGroupMemberResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_route_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_multicast_group_member_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_route_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_multicast_group_member_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_route_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_route_entry  # noqa: E501
+    def create_transit_router_multicast_group_member_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_multicast_group_member  # 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_transit_router_route_entry_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_multicast_group_member_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterRouteEntryRequest body: (required)
-        :return: CreateTransitRouterRouteEntryResponse
+        :param CreateTransitRouterMulticastGroupMemberRequest body: (required)
+        :return: CreateTransitRouterMulticastGroupMemberResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1341,14 +1535,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_route_entry" % key
+                    " to method create_transit_router_multicast_group_member" % 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_transit_router_route_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_multicast_group_member`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1376,14 +1570,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterRouteEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterMulticastGroupMember/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterRouteEntryResponse',  # noqa: E501
+            response_type='CreateTransitRouterMulticastGroupMemberResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1391,38 +1585,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_route_policy_entry(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_route_policy_entry  # noqa: E501
+    def create_transit_router_multicast_group_source(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_multicast_group_source  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.create_transit_router_route_policy_entry(body, async_req=True)
+        >>> thread = api.create_transit_router_multicast_group_source(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterRoutePolicyEntryRequest body: (required)
-        :return: CreateTransitRouterRoutePolicyEntryResponse
+        :param CreateTransitRouterMulticastGroupSourceRequest body: (required)
+        :return: CreateTransitRouterMulticastGroupSourceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_route_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_multicast_group_source_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_route_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_multicast_group_source_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_route_policy_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_route_policy_entry  # noqa: E501
+    def create_transit_router_multicast_group_source_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_multicast_group_source  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.create_transit_router_route_policy_entry_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_multicast_group_source_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterRoutePolicyEntryRequest body: (required)
-        :return: CreateTransitRouterRoutePolicyEntryResponse
+        :param CreateTransitRouterMulticastGroupSourceRequest body: (required)
+        :return: CreateTransitRouterMulticastGroupSourceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1438,14 +1632,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_route_policy_entry" % key
+                    " to method create_transit_router_multicast_group_source" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_route_policy_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_multicast_group_source`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1473,14 +1667,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterRoutePolicyEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterMulticastGroupSource/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterRoutePolicyEntryResponse',  # noqa: E501
+            response_type='CreateTransitRouterMulticastGroupSourceResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1488,38 +1682,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_route_policy_table(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_route_policy_table  # noqa: E501
+    def create_transit_router_peer_attachment(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_peer_attachment  # 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_transit_router_route_policy_table(body, async_req=True)
+        >>> thread = api.create_transit_router_peer_attachment(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterRoutePolicyTableRequest body: (required)
-        :return: CreateTransitRouterRoutePolicyTableResponse
+        :param CreateTransitRouterPeerAttachmentRequest body: (required)
+        :return: CreateTransitRouterPeerAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_route_policy_table_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_route_policy_table_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_route_policy_table_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_route_policy_table  # noqa: E501
+    def create_transit_router_peer_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_peer_attachment  # 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_transit_router_route_policy_table_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_peer_attachment_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterRoutePolicyTableRequest body: (required)
-        :return: CreateTransitRouterRoutePolicyTableResponse
+        :param CreateTransitRouterPeerAttachmentRequest body: (required)
+        :return: CreateTransitRouterPeerAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1535,14 +1729,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_route_policy_table" % key
+                    " to method create_transit_router_peer_attachment" % 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_transit_router_route_policy_table`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_peer_attachment`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1570,14 +1764,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterRoutePolicyTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterPeerAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterRoutePolicyTableResponse',  # noqa: E501
+            response_type='CreateTransitRouterPeerAttachmentResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1585,38 +1779,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_route_table(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_route_table  # noqa: E501
+    def create_transit_router_route_entry(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_route_entry  # 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_transit_router_route_table(body, async_req=True)
+        >>> thread = api.create_transit_router_route_entry(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterRouteTableRequest body: (required)
-        :return: CreateTransitRouterRouteTableResponse
+        :param CreateTransitRouterRouteEntryRequest body: (required)
+        :return: CreateTransitRouterRouteEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_route_table_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_route_entry_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_route_table_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_route_entry_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_route_table_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_route_table  # noqa: E501
+    def create_transit_router_route_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_route_entry  # 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_transit_router_route_table_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_route_entry_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterRouteTableRequest body: (required)
-        :return: CreateTransitRouterRouteTableResponse
+        :param CreateTransitRouterRouteEntryRequest body: (required)
+        :return: CreateTransitRouterRouteEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1632,14 +1826,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_route_table" % key
+                    " to method create_transit_router_route_entry" % 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_transit_router_route_table`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_route_entry`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1667,14 +1861,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterRouteTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterRouteEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterRouteTableResponse',  # noqa: E501
+            response_type='CreateTransitRouterRouteEntryResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1682,38 +1876,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_traffic_qos_marking_entry(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_traffic_qos_marking_entry  # noqa: E501
+    def create_transit_router_route_policy_entry(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_route_policy_entry  # 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_transit_router_traffic_qos_marking_entry(body, async_req=True)
+        >>> thread = api.create_transit_router_route_policy_entry(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterTrafficQosMarkingEntryRequest body: (required)
-        :return: CreateTransitRouterTrafficQosMarkingEntryResponse
+        :param CreateTransitRouterRoutePolicyEntryRequest body: (required)
+        :return: CreateTransitRouterRoutePolicyEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_traffic_qos_marking_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_route_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_traffic_qos_marking_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_route_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_traffic_qos_marking_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_traffic_qos_marking_entry  # noqa: E501
+    def create_transit_router_route_policy_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_route_policy_entry  # 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_transit_router_traffic_qos_marking_entry_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_route_policy_entry_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterTrafficQosMarkingEntryRequest body: (required)
-        :return: CreateTransitRouterTrafficQosMarkingEntryResponse
+        :param CreateTransitRouterRoutePolicyEntryRequest body: (required)
+        :return: CreateTransitRouterRoutePolicyEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1729,14 +1923,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_traffic_qos_marking_entry" % key
+                    " to method create_transit_router_route_policy_entry" % 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_transit_router_traffic_qos_marking_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_route_policy_entry`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1764,14 +1958,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterTrafficQosMarkingEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterRoutePolicyEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterTrafficQosMarkingEntryResponse',  # noqa: E501
+            response_type='CreateTransitRouterRoutePolicyEntryResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1779,38 +1973,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_traffic_qos_marking_policy(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_traffic_qos_marking_policy  # noqa: E501
+    def create_transit_router_route_policy_table(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_route_policy_table  # 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_transit_router_traffic_qos_marking_policy(body, async_req=True)
+        >>> thread = api.create_transit_router_route_policy_table(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterTrafficQosMarkingPolicyRequest body: (required)
-        :return: CreateTransitRouterTrafficQosMarkingPolicyResponse
+        :param CreateTransitRouterRoutePolicyTableRequest body: (required)
+        :return: CreateTransitRouterRoutePolicyTableResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_traffic_qos_marking_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_route_policy_table_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_traffic_qos_marking_policy_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_route_policy_table_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_traffic_qos_marking_policy_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_traffic_qos_marking_policy  # noqa: E501
+    def create_transit_router_route_policy_table_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_route_policy_table  # 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_transit_router_traffic_qos_marking_policy_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_route_policy_table_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterTrafficQosMarkingPolicyRequest body: (required)
-        :return: CreateTransitRouterTrafficQosMarkingPolicyResponse
+        :param CreateTransitRouterRoutePolicyTableRequest body: (required)
+        :return: CreateTransitRouterRoutePolicyTableResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1826,14 +2020,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_traffic_qos_marking_policy" % key
+                    " to method create_transit_router_route_policy_table" % 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_transit_router_traffic_qos_marking_policy`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_route_policy_table`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1861,14 +2055,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterTrafficQosMarkingPolicy/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterRoutePolicyTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterTrafficQosMarkingPolicyResponse',  # noqa: E501
+            response_type='CreateTransitRouterRoutePolicyTableResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1876,38 +2070,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_traffic_qos_queue_entry(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_traffic_qos_queue_entry  # noqa: E501
+    def create_transit_router_route_table(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_route_table  # 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_transit_router_traffic_qos_queue_entry(body, async_req=True)
+        >>> thread = api.create_transit_router_route_table(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterTrafficQosQueueEntryRequest body: (required)
-        :return: CreateTransitRouterTrafficQosQueueEntryResponse
+        :param CreateTransitRouterRouteTableRequest body: (required)
+        :return: CreateTransitRouterRouteTableResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_traffic_qos_queue_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_route_table_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_traffic_qos_queue_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_route_table_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_traffic_qos_queue_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_traffic_qos_queue_entry  # noqa: E501
+    def create_transit_router_route_table_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_route_table  # 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_transit_router_traffic_qos_queue_entry_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_route_table_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterTrafficQosQueueEntryRequest body: (required)
-        :return: CreateTransitRouterTrafficQosQueueEntryResponse
+        :param CreateTransitRouterRouteTableRequest body: (required)
+        :return: CreateTransitRouterRouteTableResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1923,14 +2117,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_traffic_qos_queue_entry" % key
+                    " to method create_transit_router_route_table" % 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_transit_router_traffic_qos_queue_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_route_table`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1958,14 +2152,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterTrafficQosQueueEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterRouteTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterTrafficQosQueueEntryResponse',  # noqa: E501
+            response_type='CreateTransitRouterRouteTableResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1973,38 +2167,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_traffic_qos_queue_policy(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_traffic_qos_queue_policy  # noqa: E501
+    def create_transit_router_traffic_qos_marking_entry(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_traffic_qos_marking_entry  # 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_transit_router_traffic_qos_queue_policy(body, async_req=True)
+        >>> thread = api.create_transit_router_traffic_qos_marking_entry(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterTrafficQosQueuePolicyRequest body: (required)
-        :return: CreateTransitRouterTrafficQosQueuePolicyResponse
+        :param CreateTransitRouterTrafficQosMarkingEntryRequest body: (required)
+        :return: CreateTransitRouterTrafficQosMarkingEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_traffic_qos_queue_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_traffic_qos_marking_entry_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_traffic_qos_queue_policy_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_traffic_qos_marking_entry_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_traffic_qos_queue_policy_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_traffic_qos_queue_policy  # noqa: E501
+    def create_transit_router_traffic_qos_marking_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_traffic_qos_marking_entry  # 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_transit_router_traffic_qos_queue_policy_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_traffic_qos_marking_entry_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterTrafficQosQueuePolicyRequest body: (required)
-        :return: CreateTransitRouterTrafficQosQueuePolicyResponse
+        :param CreateTransitRouterTrafficQosMarkingEntryRequest body: (required)
+        :return: CreateTransitRouterTrafficQosMarkingEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2020,14 +2214,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_traffic_qos_queue_policy" % key
+                    " to method create_transit_router_traffic_qos_marking_entry" % 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_transit_router_traffic_qos_queue_policy`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_traffic_qos_marking_entry`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2055,14 +2249,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterTrafficQosQueuePolicy/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterTrafficQosMarkingEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterTrafficQosQueuePolicyResponse',  # noqa: E501
+            response_type='CreateTransitRouterTrafficQosMarkingEntryResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2070,38 +2264,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_vpc_attachment(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_vpc_attachment  # noqa: E501
+    def create_transit_router_traffic_qos_marking_policy(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_traffic_qos_marking_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_transit_router_vpc_attachment(body, async_req=True)
+        >>> thread = api.create_transit_router_traffic_qos_marking_policy(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterVpcAttachmentRequest body: (required)
-        :return: CreateTransitRouterVpcAttachmentResponse
+        :param CreateTransitRouterTrafficQosMarkingPolicyRequest body: (required)
+        :return: CreateTransitRouterTrafficQosMarkingPolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_vpc_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_traffic_qos_marking_policy_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_vpc_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_traffic_qos_marking_policy_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_vpc_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_vpc_attachment  # noqa: E501
+    def create_transit_router_traffic_qos_marking_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_traffic_qos_marking_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_transit_router_vpc_attachment_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_traffic_qos_marking_policy_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterVpcAttachmentRequest body: (required)
-        :return: CreateTransitRouterVpcAttachmentResponse
+        :param CreateTransitRouterTrafficQosMarkingPolicyRequest body: (required)
+        :return: CreateTransitRouterTrafficQosMarkingPolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2117,14 +2311,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_vpc_attachment" % key
+                    " to method create_transit_router_traffic_qos_marking_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_transit_router_vpc_attachment`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_traffic_qos_marking_policy`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2152,14 +2346,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterVpcAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterTrafficQosMarkingPolicy/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterVpcAttachmentResponse',  # noqa: E501
+            response_type='CreateTransitRouterTrafficQosMarkingPolicyResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2167,38 +2361,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_transit_router_vpn_attachment(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_vpn_attachment  # noqa: E501
+    def create_transit_router_traffic_qos_queue_entry(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_traffic_qos_queue_entry  # 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_transit_router_vpn_attachment(body, async_req=True)
+        >>> thread = api.create_transit_router_traffic_qos_queue_entry(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterVpnAttachmentRequest body: (required)
-        :return: CreateTransitRouterVpnAttachmentResponse
+        :param CreateTransitRouterTrafficQosQueueEntryRequest body: (required)
+        :return: CreateTransitRouterTrafficQosQueueEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.create_transit_router_vpn_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_traffic_qos_queue_entry_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.create_transit_router_vpn_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_traffic_qos_queue_entry_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def create_transit_router_vpn_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
-        """create_transit_router_vpn_attachment  # noqa: E501
+    def create_transit_router_traffic_qos_queue_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_traffic_qos_queue_entry  # 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_transit_router_vpn_attachment_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_traffic_qos_queue_entry_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param CreateTransitRouterVpnAttachmentRequest body: (required)
-        :return: CreateTransitRouterVpnAttachmentResponse
+        :param CreateTransitRouterTrafficQosQueueEntryRequest body: (required)
+        :return: CreateTransitRouterTrafficQosQueueEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2214,14 +2408,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_transit_router_vpn_attachment" % key
+                    " to method create_transit_router_traffic_qos_queue_entry" % 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_transit_router_vpn_attachment`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_traffic_qos_queue_entry`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2249,14 +2443,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/CreateTransitRouterVpnAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterTrafficQosQueueEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CreateTransitRouterVpnAttachmentResponse',  # noqa: E501
+            response_type='CreateTransitRouterTrafficQosQueueEntryResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2264,38 +2458,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router  # noqa: E501
+    def create_transit_router_traffic_qos_queue_policy(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_traffic_qos_queue_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_transit_router(body, async_req=True)
+        >>> thread = api.create_transit_router_traffic_qos_queue_policy(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRequest body: (required)
-        :return: DeleteTransitRouterResponse
+        :param CreateTransitRouterTrafficQosQueuePolicyRequest body: (required)
+        :return: CreateTransitRouterTrafficQosQueuePolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_traffic_qos_queue_policy_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_traffic_qos_queue_policy_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router  # noqa: E501
+    def create_transit_router_traffic_qos_queue_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_traffic_qos_queue_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_transit_router_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_traffic_qos_queue_policy_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRequest body: (required)
-        :return: DeleteTransitRouterResponse
+        :param CreateTransitRouterTrafficQosQueuePolicyRequest body: (required)
+        :return: CreateTransitRouterTrafficQosQueuePolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2311,14 +2505,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router" % key
+                    " to method create_transit_router_traffic_qos_queue_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_transit_router`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_traffic_qos_queue_policy`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2346,14 +2540,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouter/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterTrafficQosQueuePolicy/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterResponse',  # noqa: E501
+            response_type='CreateTransitRouterTrafficQosQueuePolicyResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2361,38 +2555,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_bandwidth_package(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_bandwidth_package  # noqa: E501
+    def create_transit_router_vpc_attachment(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_vpc_attachment  # 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_transit_router_bandwidth_package(body, async_req=True)
+        >>> thread = api.create_transit_router_vpc_attachment(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterBandwidthPackageRequest body: (required)
-        :return: DeleteTransitRouterBandwidthPackageResponse
+        :param CreateTransitRouterVpcAttachmentRequest body: (required)
+        :return: CreateTransitRouterVpcAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_bandwidth_package_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_vpc_attachment_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_bandwidth_package_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_vpc_attachment_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_bandwidth_package_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_bandwidth_package  # noqa: E501
+    def create_transit_router_vpc_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_vpc_attachment  # 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_transit_router_bandwidth_package_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_vpc_attachment_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterBandwidthPackageRequest body: (required)
-        :return: DeleteTransitRouterBandwidthPackageResponse
+        :param CreateTransitRouterVpcAttachmentRequest body: (required)
+        :return: CreateTransitRouterVpcAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2408,14 +2602,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_bandwidth_package" % key
+                    " to method create_transit_router_vpc_attachment" % 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_transit_router_bandwidth_package`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_vpc_attachment`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2443,14 +2637,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterBandwidthPackage/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterVpcAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterBandwidthPackageResponse',  # noqa: E501
+            response_type='CreateTransitRouterVpcAttachmentResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2458,38 +2652,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_direct_connect_gateway_attachment(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_direct_connect_gateway_attachment  # noqa: E501
+    def create_transit_router_vpn_attachment(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_vpn_attachment  # 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_transit_router_direct_connect_gateway_attachment(body, async_req=True)
+        >>> thread = api.create_transit_router_vpn_attachment(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterDirectConnectGatewayAttachmentRequest body: (required)
-        :return: DeleteTransitRouterDirectConnectGatewayAttachmentResponse
+        :param CreateTransitRouterVpnAttachmentRequest body: (required)
+        :return: CreateTransitRouterVpnAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_direct_connect_gateway_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return self.create_transit_router_vpn_attachment_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_direct_connect_gateway_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.create_transit_router_vpn_attachment_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_direct_connect_gateway_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_direct_connect_gateway_attachment  # noqa: E501
+    def create_transit_router_vpn_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_transit_router_vpn_attachment  # 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_transit_router_direct_connect_gateway_attachment_with_http_info(body, async_req=True)
+        >>> thread = api.create_transit_router_vpn_attachment_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterDirectConnectGatewayAttachmentRequest body: (required)
-        :return: DeleteTransitRouterDirectConnectGatewayAttachmentResponse
+        :param CreateTransitRouterVpnAttachmentRequest body: (required)
+        :return: CreateTransitRouterVpnAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2505,14 +2699,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_direct_connect_gateway_attachment" % key
+                    " to method create_transit_router_vpn_attachment" % 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_transit_router_direct_connect_gateway_attachment`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_transit_router_vpn_attachment`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2540,14 +2734,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterDirectConnectGatewayAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/CreateTransitRouterVpnAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterDirectConnectGatewayAttachmentResponse',  # noqa: E501
+            response_type='CreateTransitRouterVpnAttachmentResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2555,38 +2749,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_forward_policy_entry(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_forward_policy_entry  # noqa: E501
+    def delete_transit_router(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router  # 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_transit_router_forward_policy_entry(body, async_req=True)
+        >>> thread = api.delete_transit_router(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterForwardPolicyEntryRequest body: (required)
-        :return: DeleteTransitRouterForwardPolicyEntryResponse
+        :param DeleteTransitRouterRequest body: (required)
+        :return: DeleteTransitRouterResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_forward_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_forward_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_forward_policy_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_forward_policy_entry  # noqa: E501
+    def delete_transit_router_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router  # 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_transit_router_forward_policy_entry_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterForwardPolicyEntryRequest body: (required)
-        :return: DeleteTransitRouterForwardPolicyEntryResponse
+        :param DeleteTransitRouterRequest body: (required)
+        :return: DeleteTransitRouterResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2602,14 +2796,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_forward_policy_entry" % key
+                    " to method delete_transit_router" % 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_transit_router_forward_policy_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2637,14 +2831,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterForwardPolicyEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouter/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterForwardPolicyEntryResponse',  # noqa: E501
+            response_type='DeleteTransitRouterResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2652,38 +2846,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_forward_policy_table(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_forward_policy_table  # noqa: E501
+    def delete_transit_router_bandwidth_package(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_bandwidth_package  # 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_transit_router_forward_policy_table(body, async_req=True)
+        >>> thread = api.delete_transit_router_bandwidth_package(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterForwardPolicyTableRequest body: (required)
-        :return: DeleteTransitRouterForwardPolicyTableResponse
+        :param DeleteTransitRouterBandwidthPackageRequest body: (required)
+        :return: DeleteTransitRouterBandwidthPackageResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_forward_policy_table_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_bandwidth_package_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_forward_policy_table_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_bandwidth_package_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_forward_policy_table_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_forward_policy_table  # noqa: E501
+    def delete_transit_router_bandwidth_package_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_bandwidth_package  # 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_transit_router_forward_policy_table_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_bandwidth_package_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterForwardPolicyTableRequest body: (required)
-        :return: DeleteTransitRouterForwardPolicyTableResponse
+        :param DeleteTransitRouterBandwidthPackageRequest body: (required)
+        :return: DeleteTransitRouterBandwidthPackageResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2699,14 +2893,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_forward_policy_table" % key
+                    " to method delete_transit_router_bandwidth_package" % 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_transit_router_forward_policy_table`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_bandwidth_package`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2734,14 +2928,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterForwardPolicyTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterBandwidthPackage/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterForwardPolicyTableResponse',  # noqa: E501
+            response_type='DeleteTransitRouterBandwidthPackageResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2749,38 +2943,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_grant_rule(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_grant_rule  # noqa: E501
+    def delete_transit_router_direct_connect_gateway_attachment(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_direct_connect_gateway_attachment  # 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_transit_router_grant_rule(body, async_req=True)
+        >>> thread = api.delete_transit_router_direct_connect_gateway_attachment(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterGrantRuleRequest body: (required)
-        :return: DeleteTransitRouterGrantRuleResponse
+        :param DeleteTransitRouterDirectConnectGatewayAttachmentRequest body: (required)
+        :return: DeleteTransitRouterDirectConnectGatewayAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_grant_rule_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_direct_connect_gateway_attachment_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_grant_rule_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_direct_connect_gateway_attachment_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_grant_rule_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_grant_rule  # noqa: E501
+    def delete_transit_router_direct_connect_gateway_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_direct_connect_gateway_attachment  # 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_transit_router_grant_rule_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_direct_connect_gateway_attachment_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterGrantRuleRequest body: (required)
-        :return: DeleteTransitRouterGrantRuleResponse
+        :param DeleteTransitRouterDirectConnectGatewayAttachmentRequest body: (required)
+        :return: DeleteTransitRouterDirectConnectGatewayAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2796,14 +2990,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_grant_rule" % key
+                    " to method delete_transit_router_direct_connect_gateway_attachment" % 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_transit_router_grant_rule`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_direct_connect_gateway_attachment`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2831,14 +3025,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterGrantRule/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterDirectConnectGatewayAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterGrantRuleResponse',  # noqa: E501
+            response_type='DeleteTransitRouterDirectConnectGatewayAttachmentResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2846,38 +3040,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_peer_attachment(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_peer_attachment  # noqa: E501
+    def delete_transit_router_flow_log(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_flow_log  # 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_transit_router_peer_attachment(body, async_req=True)
+        >>> thread = api.delete_transit_router_flow_log(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterPeerAttachmentRequest body: (required)
-        :return: DeleteTransitRouterPeerAttachmentResponse
+        :param DeleteTransitRouterFlowLogRequest body: (required)
+        :return: DeleteTransitRouterFlowLogResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_flow_log_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_flow_log_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_peer_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_peer_attachment  # noqa: E501
+    def delete_transit_router_flow_log_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_flow_log  # 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_transit_router_peer_attachment_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_flow_log_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterPeerAttachmentRequest body: (required)
-        :return: DeleteTransitRouterPeerAttachmentResponse
+        :param DeleteTransitRouterFlowLogRequest body: (required)
+        :return: DeleteTransitRouterFlowLogResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2893,14 +3087,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_peer_attachment" % key
+                    " to method delete_transit_router_flow_log" % 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_transit_router_peer_attachment`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_flow_log`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2928,14 +3122,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterPeerAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterFlowLog/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterPeerAttachmentResponse',  # noqa: E501
+            response_type='DeleteTransitRouterFlowLogResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2943,38 +3137,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_route_entry(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_route_entry  # noqa: E501
+    def delete_transit_router_forward_policy_entry(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_forward_policy_entry  # 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_transit_router_route_entry(body, async_req=True)
+        >>> thread = api.delete_transit_router_forward_policy_entry(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRouteEntryRequest body: (required)
-        :return: DeleteTransitRouterRouteEntryResponse
+        :param DeleteTransitRouterForwardPolicyEntryRequest body: (required)
+        :return: DeleteTransitRouterForwardPolicyEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_route_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_forward_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_route_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_forward_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_route_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_route_entry  # noqa: E501
+    def delete_transit_router_forward_policy_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_forward_policy_entry  # 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_transit_router_route_entry_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_forward_policy_entry_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRouteEntryRequest body: (required)
-        :return: DeleteTransitRouterRouteEntryResponse
+        :param DeleteTransitRouterForwardPolicyEntryRequest body: (required)
+        :return: DeleteTransitRouterForwardPolicyEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2990,14 +3184,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_route_entry" % key
+                    " to method delete_transit_router_forward_policy_entry" % 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_transit_router_route_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_forward_policy_entry`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3025,14 +3219,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterRouteEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterForwardPolicyEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterRouteEntryResponse',  # noqa: E501
+            response_type='DeleteTransitRouterForwardPolicyEntryResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3040,38 +3234,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_route_policy_entry(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_route_policy_entry  # noqa: E501
+    def delete_transit_router_forward_policy_table(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_forward_policy_table  # 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_transit_router_route_policy_entry(body, async_req=True)
+        >>> thread = api.delete_transit_router_forward_policy_table(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRoutePolicyEntryRequest body: (required)
-        :return: DeleteTransitRouterRoutePolicyEntryResponse
+        :param DeleteTransitRouterForwardPolicyTableRequest body: (required)
+        :return: DeleteTransitRouterForwardPolicyTableResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_route_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_forward_policy_table_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_route_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_forward_policy_table_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_route_policy_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_route_policy_entry  # noqa: E501
+    def delete_transit_router_forward_policy_table_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_forward_policy_table  # 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_transit_router_route_policy_entry_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_forward_policy_table_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRoutePolicyEntryRequest body: (required)
-        :return: DeleteTransitRouterRoutePolicyEntryResponse
+        :param DeleteTransitRouterForwardPolicyTableRequest body: (required)
+        :return: DeleteTransitRouterForwardPolicyTableResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3087,14 +3281,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_route_policy_entry" % key
+                    " to method delete_transit_router_forward_policy_table" % 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_transit_router_route_policy_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_forward_policy_table`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3122,14 +3316,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterRoutePolicyEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterForwardPolicyTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterRoutePolicyEntryResponse',  # noqa: E501
+            response_type='DeleteTransitRouterForwardPolicyTableResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3137,38 +3331,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_route_policy_table(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_route_policy_table  # noqa: E501
+    def delete_transit_router_grant_rule(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_grant_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_transit_router_route_policy_table(body, async_req=True)
+        >>> thread = api.delete_transit_router_grant_rule(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRoutePolicyTableRequest body: (required)
-        :return: DeleteTransitRouterRoutePolicyTableResponse
+        :param DeleteTransitRouterGrantRuleRequest body: (required)
+        :return: DeleteTransitRouterGrantRuleResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_route_policy_table_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_grant_rule_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_route_policy_table_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_grant_rule_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_route_policy_table_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_route_policy_table  # noqa: E501
+    def delete_transit_router_grant_rule_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_grant_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_transit_router_route_policy_table_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_grant_rule_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRoutePolicyTableRequest body: (required)
-        :return: DeleteTransitRouterRoutePolicyTableResponse
+        :param DeleteTransitRouterGrantRuleRequest body: (required)
+        :return: DeleteTransitRouterGrantRuleResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3184,14 +3378,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_route_policy_table" % key
+                    " to method delete_transit_router_grant_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_transit_router_route_policy_table`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_grant_rule`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3219,7 +3413,686 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterRoutePolicyTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterGrantRule/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterGrantRuleResponse',  # 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_transit_router_multicast_domain(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_multicast_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_transit_router_multicast_domain(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterMulticastDomainRequest body: (required)
+        :return: DeleteTransitRouterMulticastDomainResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_multicast_domain_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_multicast_domain_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_multicast_domain_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_multicast_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_transit_router_multicast_domain_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterMulticastDomainRequest body: (required)
+        :return: DeleteTransitRouterMulticastDomainResponse
+                 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_transit_router_multicast_domain" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_multicast_domain`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteTransitRouterMulticastDomain/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterMulticastDomainResponse',  # 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_transit_router_multicast_group_member(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_multicast_group_member  # 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_transit_router_multicast_group_member(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterMulticastGroupMemberRequest body: (required)
+        :return: DeleteTransitRouterMulticastGroupMemberResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_multicast_group_member_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_multicast_group_member_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_multicast_group_member_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_multicast_group_member  # 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_transit_router_multicast_group_member_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterMulticastGroupMemberRequest body: (required)
+        :return: DeleteTransitRouterMulticastGroupMemberResponse
+                 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_transit_router_multicast_group_member" % 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_transit_router_multicast_group_member`")  # 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(
+            '/DeleteTransitRouterMulticastGroupMember/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterMulticastGroupMemberResponse',  # 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_transit_router_multicast_group_source(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_multicast_group_source  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_transit_router_multicast_group_source(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterMulticastGroupSourceRequest body: (required)
+        :return: DeleteTransitRouterMulticastGroupSourceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_multicast_group_source_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_multicast_group_source_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_multicast_group_source_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_multicast_group_source  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_transit_router_multicast_group_source_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterMulticastGroupSourceRequest body: (required)
+        :return: DeleteTransitRouterMulticastGroupSourceResponse
+                 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_transit_router_multicast_group_source" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_multicast_group_source`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteTransitRouterMulticastGroupSource/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterMulticastGroupSourceResponse',  # 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_transit_router_peer_attachment(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_peer_attachment  # 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_transit_router_peer_attachment(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterPeerAttachmentRequest body: (required)
+        :return: DeleteTransitRouterPeerAttachmentResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_peer_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_peer_attachment  # 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_transit_router_peer_attachment_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterPeerAttachmentRequest body: (required)
+        :return: DeleteTransitRouterPeerAttachmentResponse
+                 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_transit_router_peer_attachment" % 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_transit_router_peer_attachment`")  # 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(
+            '/DeleteTransitRouterPeerAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterPeerAttachmentResponse',  # 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_transit_router_route_entry(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_route_entry  # 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_transit_router_route_entry(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterRouteEntryRequest body: (required)
+        :return: DeleteTransitRouterRouteEntryResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_route_entry_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_route_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_route_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_route_entry  # 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_transit_router_route_entry_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterRouteEntryRequest body: (required)
+        :return: DeleteTransitRouterRouteEntryResponse
+                 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_transit_router_route_entry" % 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_transit_router_route_entry`")  # 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(
+            '/DeleteTransitRouterRouteEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterRouteEntryResponse',  # 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_transit_router_route_policy_entry(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_route_policy_entry  # 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_transit_router_route_policy_entry(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterRoutePolicyEntryRequest body: (required)
+        :return: DeleteTransitRouterRoutePolicyEntryResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_route_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_route_policy_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_route_policy_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_route_policy_entry  # 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_transit_router_route_policy_entry_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterRoutePolicyEntryRequest body: (required)
+        :return: DeleteTransitRouterRoutePolicyEntryResponse
+                 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_transit_router_route_policy_entry" % 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_transit_router_route_policy_entry`")  # 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(
+            '/DeleteTransitRouterRoutePolicyEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterRoutePolicyEntryResponse',  # 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_transit_router_route_policy_table(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_route_policy_table  # 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_transit_router_route_policy_table(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterRoutePolicyTableRequest body: (required)
+        :return: DeleteTransitRouterRoutePolicyTableResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_route_policy_table_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_route_policy_table_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_route_policy_table_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_route_policy_table  # 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_transit_router_route_policy_table_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterRoutePolicyTableRequest body: (required)
+        :return: DeleteTransitRouterRoutePolicyTableResponse
+                 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_transit_router_route_policy_table" % 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_transit_router_route_policy_table`")  # 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(
+            '/DeleteTransitRouterRoutePolicyTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
@@ -3234,38 +4107,232 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_route_table(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_route_table  # noqa: E501
+    def delete_transit_router_route_table(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_route_table  # 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_transit_router_route_table(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterRouteTableRequest body: (required)
+        :return: DeleteTransitRouterRouteTableResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_route_table_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_route_table_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_route_table_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_route_table  # 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_transit_router_route_table_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterRouteTableRequest body: (required)
+        :return: DeleteTransitRouterRouteTableResponse
+                 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_transit_router_route_table" % 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_transit_router_route_table`")  # 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(
+            '/DeleteTransitRouterRouteTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterRouteTableResponse',  # 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_transit_router_traffic_qos_marking_entry(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_traffic_qos_marking_entry  # 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_transit_router_traffic_qos_marking_entry(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterTrafficQosMarkingEntryRequest body: (required)
+        :return: DeleteTransitRouterTrafficQosMarkingEntryResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_traffic_qos_marking_entry_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_traffic_qos_marking_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_traffic_qos_marking_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_traffic_qos_marking_entry  # 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_transit_router_traffic_qos_marking_entry_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterTrafficQosMarkingEntryRequest body: (required)
+        :return: DeleteTransitRouterTrafficQosMarkingEntryResponse
+                 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_transit_router_traffic_qos_marking_entry" % 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_transit_router_traffic_qos_marking_entry`")  # 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(
+            '/DeleteTransitRouterTrafficQosMarkingEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterTrafficQosMarkingEntryResponse',  # 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_transit_router_traffic_qos_marking_policy(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_traffic_qos_marking_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_transit_router_route_table(body, async_req=True)
+        >>> thread = api.delete_transit_router_traffic_qos_marking_policy(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRouteTableRequest body: (required)
-        :return: DeleteTransitRouterRouteTableResponse
+        :param DeleteTransitRouterTrafficQosMarkingPolicyRequest body: (required)
+        :return: DeleteTransitRouterTrafficQosMarkingPolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_route_table_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_traffic_qos_marking_policy_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_route_table_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_traffic_qos_marking_policy_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_route_table_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_route_table  # noqa: E501
+    def delete_transit_router_traffic_qos_marking_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_traffic_qos_marking_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_transit_router_route_table_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_traffic_qos_marking_policy_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterRouteTableRequest body: (required)
-        :return: DeleteTransitRouterRouteTableResponse
+        :param DeleteTransitRouterTrafficQosMarkingPolicyRequest body: (required)
+        :return: DeleteTransitRouterTrafficQosMarkingPolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3281,14 +4348,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_route_table" % key
+                    " to method delete_transit_router_traffic_qos_marking_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_transit_router_route_table`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_traffic_qos_marking_policy`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3316,14 +4383,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterRouteTable/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterTrafficQosMarkingPolicy/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterRouteTableResponse',  # noqa: E501
+            response_type='DeleteTransitRouterTrafficQosMarkingPolicyResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3331,38 +4398,232 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_traffic_qos_marking_entry(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_traffic_qos_marking_entry  # noqa: E501
+    def delete_transit_router_traffic_qos_queue_entry(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_traffic_qos_queue_entry  # 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_transit_router_traffic_qos_marking_entry(body, async_req=True)
+        >>> thread = api.delete_transit_router_traffic_qos_queue_entry(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterTrafficQosMarkingEntryRequest body: (required)
-        :return: DeleteTransitRouterTrafficQosMarkingEntryResponse
+        :param DeleteTransitRouterTrafficQosQueueEntryRequest body: (required)
+        :return: DeleteTransitRouterTrafficQosQueueEntryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_traffic_qos_marking_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_traffic_qos_queue_entry_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_traffic_qos_marking_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_traffic_qos_queue_entry_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_traffic_qos_marking_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_traffic_qos_marking_entry  # noqa: E501
+    def delete_transit_router_traffic_qos_queue_entry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_traffic_qos_queue_entry  # 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_transit_router_traffic_qos_queue_entry_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterTrafficQosQueueEntryRequest body: (required)
+        :return: DeleteTransitRouterTrafficQosQueueEntryResponse
+                 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_transit_router_traffic_qos_queue_entry" % 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_transit_router_traffic_qos_queue_entry`")  # 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(
+            '/DeleteTransitRouterTrafficQosQueueEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterTrafficQosQueueEntryResponse',  # 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_transit_router_traffic_qos_queue_policy(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_traffic_qos_queue_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_transit_router_traffic_qos_queue_policy(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterTrafficQosQueuePolicyRequest body: (required)
+        :return: DeleteTransitRouterTrafficQosQueuePolicyResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_traffic_qos_queue_policy_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_traffic_qos_queue_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_traffic_qos_queue_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_traffic_qos_queue_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_transit_router_traffic_qos_queue_policy_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterTrafficQosQueuePolicyRequest body: (required)
+        :return: DeleteTransitRouterTrafficQosQueuePolicyResponse
+                 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_transit_router_traffic_qos_queue_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_transit_router_traffic_qos_queue_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(
+            '/DeleteTransitRouterTrafficQosQueuePolicy/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteTransitRouterTrafficQosQueuePolicyResponse',  # 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_transit_router_vpc_attachment(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_vpc_attachment  # 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_transit_router_vpc_attachment(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteTransitRouterVpcAttachmentRequest body: (required)
+        :return: DeleteTransitRouterVpcAttachmentResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_transit_router_vpc_attachment_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_transit_router_vpc_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_transit_router_vpc_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_vpc_attachment  # 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_transit_router_traffic_qos_marking_entry_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_vpc_attachment_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterTrafficQosMarkingEntryRequest body: (required)
-        :return: DeleteTransitRouterTrafficQosMarkingEntryResponse
+        :param DeleteTransitRouterVpcAttachmentRequest body: (required)
+        :return: DeleteTransitRouterVpcAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3378,14 +4639,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_traffic_qos_marking_entry" % key
+                    " to method delete_transit_router_vpc_attachment" % 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_transit_router_traffic_qos_marking_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_vpc_attachment`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3413,14 +4674,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterTrafficQosMarkingEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterVpcAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterTrafficQosMarkingEntryResponse',  # noqa: E501
+            response_type='DeleteTransitRouterVpcAttachmentResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3428,38 +4689,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_traffic_qos_marking_policy(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_traffic_qos_marking_policy  # noqa: E501
+    def delete_transit_router_vpn_attachment(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_vpn_attachment  # 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_transit_router_traffic_qos_marking_policy(body, async_req=True)
+        >>> thread = api.delete_transit_router_vpn_attachment(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterTrafficQosMarkingPolicyRequest body: (required)
-        :return: DeleteTransitRouterTrafficQosMarkingPolicyResponse
+        :param DeleteTransitRouterVpnAttachmentRequest body: (required)
+        :return: DeleteTransitRouterVpnAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_traffic_qos_marking_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_transit_router_vpn_attachment_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_traffic_qos_marking_policy_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_transit_router_vpn_attachment_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_traffic_qos_marking_policy_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_traffic_qos_marking_policy  # noqa: E501
+    def delete_transit_router_vpn_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_transit_router_vpn_attachment  # 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_transit_router_traffic_qos_marking_policy_with_http_info(body, async_req=True)
+        >>> thread = api.delete_transit_router_vpn_attachment_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterTrafficQosMarkingPolicyRequest body: (required)
-        :return: DeleteTransitRouterTrafficQosMarkingPolicyResponse
+        :param DeleteTransitRouterVpnAttachmentRequest body: (required)
+        :return: DeleteTransitRouterVpnAttachmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3475,14 +4736,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_traffic_qos_marking_policy" % key
+                    " to method delete_transit_router_vpn_attachment" % 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_transit_router_traffic_qos_marking_policy`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_transit_router_vpn_attachment`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3510,14 +4771,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterTrafficQosMarkingPolicy/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DeleteTransitRouterVpnAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterTrafficQosMarkingPolicyResponse',  # noqa: E501
+            response_type='DeleteTransitRouterVpnAttachmentResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3525,38 +4786,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_traffic_qos_queue_entry(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_traffic_qos_queue_entry  # noqa: E501
+    def describe_transit_router_attachments(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_attachments  # 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_transit_router_traffic_qos_queue_entry(body, async_req=True)
+        >>> thread = api.describe_transit_router_attachments(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterTrafficQosQueueEntryRequest body: (required)
-        :return: DeleteTransitRouterTrafficQosQueueEntryResponse
+        :param DescribeTransitRouterAttachmentsRequest body: (required)
+        :return: DescribeTransitRouterAttachmentsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_traffic_qos_queue_entry_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_attachments_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_traffic_qos_queue_entry_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_attachments_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_traffic_qos_queue_entry_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_traffic_qos_queue_entry  # noqa: E501
+    def describe_transit_router_attachments_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_attachments  # 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_transit_router_traffic_qos_queue_entry_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_attachments_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterTrafficQosQueueEntryRequest body: (required)
-        :return: DeleteTransitRouterTrafficQosQueueEntryResponse
+        :param DescribeTransitRouterAttachmentsRequest body: (required)
+        :return: DescribeTransitRouterAttachmentsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3572,14 +4833,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_traffic_qos_queue_entry" % key
+                    " to method describe_transit_router_attachments" % 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_transit_router_traffic_qos_queue_entry`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_attachments`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3607,14 +4868,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterTrafficQosQueueEntry/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterAttachments/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterTrafficQosQueueEntryResponse',  # noqa: E501
+            response_type='DescribeTransitRouterAttachmentsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3622,38 +4883,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_traffic_qos_queue_policy(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_traffic_qos_queue_policy  # noqa: E501
+    def describe_transit_router_bandwidth_packages(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_bandwidth_packages  # 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_transit_router_traffic_qos_queue_policy(body, async_req=True)
+        >>> thread = api.describe_transit_router_bandwidth_packages(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterTrafficQosQueuePolicyRequest body: (required)
-        :return: DeleteTransitRouterTrafficQosQueuePolicyResponse
+        :param DescribeTransitRouterBandwidthPackagesRequest body: (required)
+        :return: DescribeTransitRouterBandwidthPackagesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_traffic_qos_queue_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_bandwidth_packages_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_traffic_qos_queue_policy_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_bandwidth_packages_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_traffic_qos_queue_policy_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_traffic_qos_queue_policy  # noqa: E501
+    def describe_transit_router_bandwidth_packages_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_bandwidth_packages  # 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_transit_router_traffic_qos_queue_policy_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_bandwidth_packages_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterTrafficQosQueuePolicyRequest body: (required)
-        :return: DeleteTransitRouterTrafficQosQueuePolicyResponse
+        :param DescribeTransitRouterBandwidthPackagesRequest body: (required)
+        :return: DescribeTransitRouterBandwidthPackagesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3669,14 +4930,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_traffic_qos_queue_policy" % key
+                    " to method describe_transit_router_bandwidth_packages" % 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_transit_router_traffic_qos_queue_policy`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_bandwidth_packages`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3704,14 +4965,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterTrafficQosQueuePolicy/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterBandwidthPackages/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterTrafficQosQueuePolicyResponse',  # noqa: E501
+            response_type='DescribeTransitRouterBandwidthPackagesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3719,38 +4980,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_vpc_attachment(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_vpc_attachment  # noqa: E501
+    def describe_transit_router_bandwidth_packages_billing(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_bandwidth_packages_billing  # 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_transit_router_vpc_attachment(body, async_req=True)
+        >>> thread = api.describe_transit_router_bandwidth_packages_billing(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterVpcAttachmentRequest body: (required)
-        :return: DeleteTransitRouterVpcAttachmentResponse
+        :param DescribeTransitRouterBandwidthPackagesBillingRequest body: (required)
+        :return: DescribeTransitRouterBandwidthPackagesBillingResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_vpc_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_bandwidth_packages_billing_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_vpc_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_bandwidth_packages_billing_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_vpc_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_vpc_attachment  # noqa: E501
+    def describe_transit_router_bandwidth_packages_billing_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_bandwidth_packages_billing  # 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_transit_router_vpc_attachment_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_bandwidth_packages_billing_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterVpcAttachmentRequest body: (required)
-        :return: DeleteTransitRouterVpcAttachmentResponse
+        :param DescribeTransitRouterBandwidthPackagesBillingRequest body: (required)
+        :return: DescribeTransitRouterBandwidthPackagesBillingResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3766,14 +5027,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_vpc_attachment" % key
+                    " to method describe_transit_router_bandwidth_packages_billing" % 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_transit_router_vpc_attachment`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_bandwidth_packages_billing`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3801,14 +5062,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterVpcAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterBandwidthPackagesBilling/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterVpcAttachmentResponse',  # noqa: E501
+            response_type='DescribeTransitRouterBandwidthPackagesBillingResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3816,38 +5077,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_transit_router_vpn_attachment(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_vpn_attachment  # noqa: E501
+    def describe_transit_router_direct_connect_gateway_attachments(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_direct_connect_gateway_attachments  # 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_transit_router_vpn_attachment(body, async_req=True)
+        >>> thread = api.describe_transit_router_direct_connect_gateway_attachments(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterVpnAttachmentRequest body: (required)
-        :return: DeleteTransitRouterVpnAttachmentResponse
+        :param DescribeTransitRouterDirectConnectGatewayAttachmentsRequest body: (required)
+        :return: DescribeTransitRouterDirectConnectGatewayAttachmentsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_transit_router_vpn_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_direct_connect_gateway_attachments_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_transit_router_vpn_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_direct_connect_gateway_attachments_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_transit_router_vpn_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_vpn_attachment  # noqa: E501
+    def describe_transit_router_direct_connect_gateway_attachments_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_direct_connect_gateway_attachments  # 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_transit_router_vpn_attachment_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_direct_connect_gateway_attachments_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterVpnAttachmentRequest body: (required)
-        :return: DeleteTransitRouterVpnAttachmentResponse
+        :param DescribeTransitRouterDirectConnectGatewayAttachmentsRequest body: (required)
+        :return: DescribeTransitRouterDirectConnectGatewayAttachmentsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3863,14 +5124,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_vpn_attachment" % key
+                    " to method describe_transit_router_direct_connect_gateway_attachments" % 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_transit_router_vpn_attachment`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_direct_connect_gateway_attachments`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3898,14 +5159,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteTransitRouterVpnAttachment/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterDirectConnectGatewayAttachments/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteTransitRouterVpnAttachmentResponse',  # noqa: E501
+            response_type='DescribeTransitRouterDirectConnectGatewayAttachmentsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3913,38 +5174,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_transit_router_attachments(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_attachments  # noqa: E501
+    def describe_transit_router_flow_logs(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_flow_logs  # 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_transit_router_attachments(body, async_req=True)
+        >>> thread = api.describe_transit_router_flow_logs(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterAttachmentsRequest body: (required)
-        :return: DescribeTransitRouterAttachmentsResponse
+        :param DescribeTransitRouterFlowLogsRequest body: (required)
+        :return: DescribeTransitRouterFlowLogsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_transit_router_attachments_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_flow_logs_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_transit_router_attachments_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_flow_logs_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_transit_router_attachments_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_attachments  # noqa: E501
+    def describe_transit_router_flow_logs_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_flow_logs  # 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_transit_router_attachments_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_flow_logs_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterAttachmentsRequest body: (required)
-        :return: DescribeTransitRouterAttachmentsResponse
+        :param DescribeTransitRouterFlowLogsRequest body: (required)
+        :return: DescribeTransitRouterFlowLogsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3960,14 +5221,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_transit_router_attachments" % key
+                    " to method describe_transit_router_flow_logs" % 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_transit_router_attachments`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_flow_logs`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3995,14 +5256,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeTransitRouterAttachments/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterFlowLogs/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeTransitRouterAttachmentsResponse',  # noqa: E501
+            response_type='DescribeTransitRouterFlowLogsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4010,38 +5271,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_transit_router_bandwidth_packages(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_bandwidth_packages  # noqa: E501
+    def describe_transit_router_forward_policy_entries(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_forward_policy_entries  # 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_transit_router_bandwidth_packages(body, async_req=True)
+        >>> thread = api.describe_transit_router_forward_policy_entries(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterBandwidthPackagesRequest body: (required)
-        :return: DescribeTransitRouterBandwidthPackagesResponse
+        :param DescribeTransitRouterForwardPolicyEntriesRequest body: (required)
+        :return: DescribeTransitRouterForwardPolicyEntriesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_transit_router_bandwidth_packages_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_forward_policy_entries_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_transit_router_bandwidth_packages_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_forward_policy_entries_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_transit_router_bandwidth_packages_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_bandwidth_packages  # noqa: E501
+    def describe_transit_router_forward_policy_entries_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_forward_policy_entries  # 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_transit_router_bandwidth_packages_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_forward_policy_entries_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterBandwidthPackagesRequest body: (required)
-        :return: DescribeTransitRouterBandwidthPackagesResponse
+        :param DescribeTransitRouterForwardPolicyEntriesRequest body: (required)
+        :return: DescribeTransitRouterForwardPolicyEntriesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4057,14 +5318,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_transit_router_bandwidth_packages" % key
+                    " to method describe_transit_router_forward_policy_entries" % 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_transit_router_bandwidth_packages`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_forward_policy_entries`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4092,14 +5353,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeTransitRouterBandwidthPackages/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterForwardPolicyEntries/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeTransitRouterBandwidthPackagesResponse',  # noqa: E501
+            response_type='DescribeTransitRouterForwardPolicyEntriesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4107,38 +5368,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_transit_router_bandwidth_packages_billing(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_bandwidth_packages_billing  # noqa: E501
+    def describe_transit_router_forward_policy_tables(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_forward_policy_tables  # 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_transit_router_bandwidth_packages_billing(body, async_req=True)
+        >>> thread = api.describe_transit_router_forward_policy_tables(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterBandwidthPackagesBillingRequest body: (required)
-        :return: DescribeTransitRouterBandwidthPackagesBillingResponse
+        :param DescribeTransitRouterForwardPolicyTablesRequest body: (required)
+        :return: DescribeTransitRouterForwardPolicyTablesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_transit_router_bandwidth_packages_billing_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_forward_policy_tables_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_transit_router_bandwidth_packages_billing_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_forward_policy_tables_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_transit_router_bandwidth_packages_billing_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_bandwidth_packages_billing  # noqa: E501
+    def describe_transit_router_forward_policy_tables_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_forward_policy_tables  # 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_transit_router_bandwidth_packages_billing_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_forward_policy_tables_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterBandwidthPackagesBillingRequest body: (required)
-        :return: DescribeTransitRouterBandwidthPackagesBillingResponse
+        :param DescribeTransitRouterForwardPolicyTablesRequest body: (required)
+        :return: DescribeTransitRouterForwardPolicyTablesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4154,14 +5415,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_transit_router_bandwidth_packages_billing" % key
+                    " to method describe_transit_router_forward_policy_tables" % 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_transit_router_bandwidth_packages_billing`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_forward_policy_tables`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4189,14 +5450,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeTransitRouterBandwidthPackagesBilling/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterForwardPolicyTables/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeTransitRouterBandwidthPackagesBillingResponse',  # noqa: E501
+            response_type='DescribeTransitRouterForwardPolicyTablesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4204,38 +5465,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_transit_router_direct_connect_gateway_attachments(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_direct_connect_gateway_attachments  # noqa: E501
+    def describe_transit_router_grant_rules(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_grant_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_transit_router_direct_connect_gateway_attachments(body, async_req=True)
+        >>> thread = api.describe_transit_router_grant_rules(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterDirectConnectGatewayAttachmentsRequest body: (required)
-        :return: DescribeTransitRouterDirectConnectGatewayAttachmentsResponse
+        :param DescribeTransitRouterGrantRulesRequest body: (required)
+        :return: DescribeTransitRouterGrantRulesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_transit_router_direct_connect_gateway_attachments_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_grant_rules_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_transit_router_direct_connect_gateway_attachments_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_grant_rules_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_transit_router_direct_connect_gateway_attachments_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_direct_connect_gateway_attachments  # noqa: E501
+    def describe_transit_router_grant_rules_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_grant_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_transit_router_direct_connect_gateway_attachments_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_grant_rules_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterDirectConnectGatewayAttachmentsRequest body: (required)
-        :return: DescribeTransitRouterDirectConnectGatewayAttachmentsResponse
+        :param DescribeTransitRouterGrantRulesRequest body: (required)
+        :return: DescribeTransitRouterGrantRulesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4251,14 +5512,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_transit_router_direct_connect_gateway_attachments" % key
+                    " to method describe_transit_router_grant_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_transit_router_direct_connect_gateway_attachments`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_grant_rules`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4286,14 +5547,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeTransitRouterDirectConnectGatewayAttachments/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterGrantRules/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeTransitRouterDirectConnectGatewayAttachmentsResponse',  # noqa: E501
+            response_type='DescribeTransitRouterGrantRulesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4301,38 +5562,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_transit_router_forward_policy_entries(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_forward_policy_entries  # noqa: E501
+    def describe_transit_router_multicast_domain_associations(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_multicast_domain_associations  # 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_transit_router_forward_policy_entries(body, async_req=True)
+        >>> thread = api.describe_transit_router_multicast_domain_associations(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterForwardPolicyEntriesRequest body: (required)
-        :return: DescribeTransitRouterForwardPolicyEntriesResponse
+        :param DescribeTransitRouterMulticastDomainAssociationsRequest body: (required)
+        :return: DescribeTransitRouterMulticastDomainAssociationsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_transit_router_forward_policy_entries_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_multicast_domain_associations_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_transit_router_forward_policy_entries_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_multicast_domain_associations_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_transit_router_forward_policy_entries_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_forward_policy_entries  # noqa: E501
+    def describe_transit_router_multicast_domain_associations_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_multicast_domain_associations  # 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_transit_router_forward_policy_entries_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_multicast_domain_associations_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterForwardPolicyEntriesRequest body: (required)
-        :return: DescribeTransitRouterForwardPolicyEntriesResponse
+        :param DescribeTransitRouterMulticastDomainAssociationsRequest body: (required)
+        :return: DescribeTransitRouterMulticastDomainAssociationsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4348,14 +5609,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_transit_router_forward_policy_entries" % key
+                    " to method describe_transit_router_multicast_domain_associations" % 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_transit_router_forward_policy_entries`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_multicast_domain_associations`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4383,14 +5644,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeTransitRouterForwardPolicyEntries/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterMulticastDomainAssociations/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeTransitRouterForwardPolicyEntriesResponse',  # noqa: E501
+            response_type='DescribeTransitRouterMulticastDomainAssociationsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4398,38 +5659,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_transit_router_forward_policy_tables(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_forward_policy_tables  # noqa: E501
+    def describe_transit_router_multicast_domains(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_multicast_domains  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_transit_router_forward_policy_tables(body, async_req=True)
+        >>> thread = api.describe_transit_router_multicast_domains(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterForwardPolicyTablesRequest body: (required)
-        :return: DescribeTransitRouterForwardPolicyTablesResponse
+        :param DescribeTransitRouterMulticastDomainsRequest body: (required)
+        :return: DescribeTransitRouterMulticastDomainsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_transit_router_forward_policy_tables_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_multicast_domains_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_transit_router_forward_policy_tables_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_multicast_domains_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_transit_router_forward_policy_tables_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_forward_policy_tables  # noqa: E501
+    def describe_transit_router_multicast_domains_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_multicast_domains  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_transit_router_forward_policy_tables_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_multicast_domains_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterForwardPolicyTablesRequest body: (required)
-        :return: DescribeTransitRouterForwardPolicyTablesResponse
+        :param DescribeTransitRouterMulticastDomainsRequest body: (required)
+        :return: DescribeTransitRouterMulticastDomainsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4445,14 +5706,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_transit_router_forward_policy_tables" % key
+                    " to method describe_transit_router_multicast_domains" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_forward_policy_tables`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_multicast_domains`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4480,14 +5741,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeTransitRouterForwardPolicyTables/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterMulticastDomains/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeTransitRouterForwardPolicyTablesResponse',  # noqa: E501
+            response_type='DescribeTransitRouterMulticastDomainsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4495,38 +5756,38 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_transit_router_grant_rules(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_grant_rules  # noqa: E501
+    def describe_transit_router_multicast_groups(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_multicast_groups  # 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_transit_router_grant_rules(body, async_req=True)
+        >>> thread = api.describe_transit_router_multicast_groups(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterGrantRulesRequest body: (required)
-        :return: DescribeTransitRouterGrantRulesResponse
+        :param DescribeTransitRouterMulticastGroupsRequest body: (required)
+        :return: DescribeTransitRouterMulticastGroupsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_transit_router_grant_rules_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_transit_router_multicast_groups_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_transit_router_grant_rules_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_transit_router_multicast_groups_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_transit_router_grant_rules_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_transit_router_grant_rules  # noqa: E501
+    def describe_transit_router_multicast_groups_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_transit_router_multicast_groups  # 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_transit_router_grant_rules_with_http_info(body, async_req=True)
+        >>> thread = api.describe_transit_router_multicast_groups_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeTransitRouterGrantRulesRequest body: (required)
-        :return: DescribeTransitRouterGrantRulesResponse
+        :param DescribeTransitRouterMulticastGroupsRequest body: (required)
+        :return: DescribeTransitRouterMulticastGroupsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4542,14 +5803,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_transit_router_grant_rules" % key
+                    " to method describe_transit_router_multicast_groups" % 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_transit_router_grant_rules`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_transit_router_multicast_groups`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4577,14 +5838,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeTransitRouterGrantRules/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/DescribeTransitRouterMulticastGroups/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeTransitRouterGrantRulesResponse',  # noqa: E501
+            response_type='DescribeTransitRouterMulticastGroupsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -6338,6 +7599,103 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def dissociate_transit_router_multicast_domain(self, body, **kwargs):  # noqa: E501
+        """dissociate_transit_router_multicast_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.dissociate_transit_router_multicast_domain(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DissociateTransitRouterMulticastDomainRequest body: (required)
+        :return: DissociateTransitRouterMulticastDomainResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.dissociate_transit_router_multicast_domain_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.dissociate_transit_router_multicast_domain_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def dissociate_transit_router_multicast_domain_with_http_info(self, body, **kwargs):  # noqa: E501
+        """dissociate_transit_router_multicast_domain  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.dissociate_transit_router_multicast_domain_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DissociateTransitRouterMulticastDomainRequest body: (required)
+        :return: DissociateTransitRouterMulticastDomainResponse
+                 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 dissociate_transit_router_multicast_domain" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `dissociate_transit_router_multicast_domain`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DissociateTransitRouterMulticastDomain/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DissociateTransitRouterMulticastDomainResponse',  # 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 dissociate_transit_router_route_policy_from_route_table(self, body, **kwargs):  # noqa: E501
         """dissociate_transit_router_route_policy_from_route_table  # noqa: E501
 
@@ -7026,29 +8384,126 @@ class TRANSITROUTERApi(object):
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyTransitRouterDirectConnectGatewayAttachmentAttributesRequest body: (required)
-        :return: ModifyTransitRouterDirectConnectGatewayAttachmentAttributesResponse
+        :param ModifyTransitRouterDirectConnectGatewayAttachmentAttributesRequest body: (required)
+        :return: ModifyTransitRouterDirectConnectGatewayAttachmentAttributesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.modify_transit_router_direct_connect_gateway_attachment_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_transit_router_direct_connect_gateway_attachment_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_transit_router_direct_connect_gateway_attachment_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_direct_connect_gateway_attachment_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_transit_router_direct_connect_gateway_attachment_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyTransitRouterDirectConnectGatewayAttachmentAttributesRequest body: (required)
+        :return: ModifyTransitRouterDirectConnectGatewayAttachmentAttributesResponse
+                 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 modify_transit_router_direct_connect_gateway_attachment_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_transit_router_direct_connect_gateway_attachment_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(
+            '/ModifyTransitRouterDirectConnectGatewayAttachmentAttributes/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ModifyTransitRouterDirectConnectGatewayAttachmentAttributesResponse',  # 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 modify_transit_router_flow_log_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_flow_log_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_transit_router_flow_log_attributes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyTransitRouterFlowLogAttributesRequest body: (required)
+        :return: ModifyTransitRouterFlowLogAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_transit_router_direct_connect_gateway_attachment_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_transit_router_flow_log_attributes_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_transit_router_direct_connect_gateway_attachment_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_transit_router_flow_log_attributes_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_transit_router_direct_connect_gateway_attachment_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_transit_router_direct_connect_gateway_attachment_attributes  # noqa: E501
+    def modify_transit_router_flow_log_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_flow_log_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_transit_router_direct_connect_gateway_attachment_attributes_with_http_info(body, async_req=True)
+        >>> thread = api.modify_transit_router_flow_log_attributes_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyTransitRouterDirectConnectGatewayAttachmentAttributesRequest body: (required)
-        :return: ModifyTransitRouterDirectConnectGatewayAttachmentAttributesResponse
+        :param ModifyTransitRouterFlowLogAttributesRequest body: (required)
+        :return: ModifyTransitRouterFlowLogAttributesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -7064,14 +8519,14 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_transit_router_direct_connect_gateway_attachment_attributes" % key
+                    " to method modify_transit_router_flow_log_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_transit_router_direct_connect_gateway_attachment_attributes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_transit_router_flow_log_attributes`")  # noqa: E501
 
         collection_formats = {}
 
@@ -7099,14 +8554,14 @@ class TRANSITROUTERApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyTransitRouterDirectConnectGatewayAttachmentAttributes/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            '/ModifyTransitRouterFlowLogAttributes/2020-04-01/transitrouter/get/text_plain/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyTransitRouterDirectConnectGatewayAttachmentAttributesResponse',  # noqa: E501
+            response_type='ModifyTransitRouterFlowLogAttributesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -7502,6 +8957,103 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def modify_transit_router_multicast_domain_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_multicast_domain_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_transit_router_multicast_domain_attributes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyTransitRouterMulticastDomainAttributesRequest body: (required)
+        :return: ModifyTransitRouterMulticastDomainAttributesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.modify_transit_router_multicast_domain_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_transit_router_multicast_domain_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_transit_router_multicast_domain_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_multicast_domain_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_transit_router_multicast_domain_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyTransitRouterMulticastDomainAttributesRequest body: (required)
+        :return: ModifyTransitRouterMulticastDomainAttributesResponse
+                 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 modify_transit_router_multicast_domain_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_transit_router_multicast_domain_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(
+            '/ModifyTransitRouterMulticastDomainAttributes/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ModifyTransitRouterMulticastDomainAttributesResponse',  # 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 modify_transit_router_peer_attachment_attributes(self, body, **kwargs):  # noqa: E501
         """modify_transit_router_peer_attachment_attributes  # noqa: E501
 
@@ -9054,6 +10606,200 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def start_transit_router_flow_log(self, body, **kwargs):  # noqa: E501
+        """start_transit_router_flow_log  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.start_transit_router_flow_log(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param StartTransitRouterFlowLogRequest body: (required)
+        :return: StartTransitRouterFlowLogResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.start_transit_router_flow_log_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.start_transit_router_flow_log_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def start_transit_router_flow_log_with_http_info(self, body, **kwargs):  # noqa: E501
+        """start_transit_router_flow_log  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.start_transit_router_flow_log_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param StartTransitRouterFlowLogRequest body: (required)
+        :return: StartTransitRouterFlowLogResponse
+                 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 start_transit_router_flow_log" % 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 `start_transit_router_flow_log`")  # 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(
+            '/StartTransitRouterFlowLog/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='StartTransitRouterFlowLogResponse',  # 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 stop_transit_router_flow_log(self, body, **kwargs):  # noqa: E501
+        """stop_transit_router_flow_log  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.stop_transit_router_flow_log(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param StopTransitRouterFlowLogRequest body: (required)
+        :return: StopTransitRouterFlowLogResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.stop_transit_router_flow_log_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.stop_transit_router_flow_log_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def stop_transit_router_flow_log_with_http_info(self, body, **kwargs):  # noqa: E501
+        """stop_transit_router_flow_log  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.stop_transit_router_flow_log_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param StopTransitRouterFlowLogRequest body: (required)
+        :return: StopTransitRouterFlowLogResponse
+                 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 stop_transit_router_flow_log" % 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 `stop_transit_router_flow_log`")  # 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(
+            '/StopTransitRouterFlowLog/2020-04-01/transitrouter/get/text_plain/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='StopTransitRouterFlowLogResponse',  # 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 tag_resources(self, body, **kwargs):  # noqa: E501
         """tag_resources  # noqa: E501