byteplus-python-sdk-v2 3.0.51__py2.py3-none-any.whl → 3.0.53__py2.py3-none-any.whl

byteplussdktransitrouter/api/transitrouter_api.py

@@ -33,6 +33,200 @@ class TRANSITROUTERApi(object):
             api_client = byteplussdkcore.ApiClient()
         self.api_client = api_client
 
+    def accept_shared_transit_router(self, body, **kwargs):  # noqa: E501
+        """accept_shared_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.accept_shared_transit_router(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AcceptSharedTransitRouterRequest body: (required)
+        :return: AcceptSharedTransitRouterResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.accept_shared_transit_router_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.accept_shared_transit_router_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def accept_shared_transit_router_with_http_info(self, body, **kwargs):  # noqa: E501
+        """accept_shared_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.accept_shared_transit_router_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AcceptSharedTransitRouterRequest body: (required)
+        :return: AcceptSharedTransitRouterResponse
+                 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 accept_shared_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 `accept_shared_transit_router`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/AcceptSharedTransitRouter/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='AcceptSharedTransitRouterResponse',  # 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 accept_transit_router_peer_attachment(self, body, **kwargs):  # noqa: E501
+        """accept_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.accept_transit_router_peer_attachment(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AcceptTransitRouterPeerAttachmentRequest body: (required)
+        :return: AcceptTransitRouterPeerAttachmentResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.accept_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.accept_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def accept_transit_router_peer_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """accept_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.accept_transit_router_peer_attachment_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param AcceptTransitRouterPeerAttachmentRequest body: (required)
+        :return: AcceptTransitRouterPeerAttachmentResponse
+                 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 accept_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 `accept_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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/AcceptTransitRouterPeerAttachment/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='AcceptTransitRouterPeerAttachmentResponse',  # 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_attachment_to_route_table(self, body, **kwargs):  # noqa: E501
         """associate_transit_router_attachment_to_route_table  # noqa: E501
 
@@ -1197,6 +1391,103 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def create_transit_router_grant_rule(self, body, **kwargs):  # noqa: E501
+        """create_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.create_transit_router_grant_rule(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateTransitRouterGrantRuleRequest body: (required)
+        :return: CreateTransitRouterGrantRuleResponse
+                 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_grant_rule_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.create_transit_router_grant_rule_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def create_transit_router_grant_rule_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_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.create_transit_router_grant_rule_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateTransitRouterGrantRuleRequest body: (required)
+        :return: CreateTransitRouterGrantRuleResponse
+                 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_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 `create_transit_router_grant_rule`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/CreateTransitRouterGrantRule/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='CreateTransitRouterGrantRuleResponse',  # 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_multicast_domain(self, body, **kwargs):  # noqa: E501
         """create_transit_router_multicast_domain  # noqa: E501
 
@@ -3137,38 +3428,38 @@ class TRANSITROUTERApi(object):
             _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
+    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_multicast_domain(body, async_req=True)
+        >>> thread = api.delete_transit_router_grant_rule(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteTransitRouterMulticastDomainRequest body: (required)
-        :return: DeleteTransitRouterMulticastDomainResponse
+        :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_multicast_domain_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_multicast_domain_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_multicast_domain_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_transit_router_multicast_domain  # 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_multicast_domain_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 DeleteTransitRouterMulticastDomainRequest body: (required)
-        :return: DeleteTransitRouterMulticastDomainResponse
+        :param DeleteTransitRouterGrantRuleRequest body: (required)
+        :return: DeleteTransitRouterGrantRuleResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3184,7 +3475,104 @@ class TRANSITROUTERApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_transit_router_multicast_domain" % 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_grant_rule`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['text/plain'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/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']
@@ -4495,6 +4883,103 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def describe95_traffic(self, body, **kwargs):  # noqa: E501
+        """describe95_traffic  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe95_traffic(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param Describe95TrafficRequest body: (required)
+        :return: Describe95TrafficResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe95_traffic_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe95_traffic_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe95_traffic_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe95_traffic  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.describe95_traffic_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param Describe95TrafficRequest body: (required)
+        :return: Describe95TrafficResponse
+                 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 describe95_traffic" % 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 `describe95_traffic`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/Describe95Traffic/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='Describe95TrafficResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def describe_transit_router_attachments(self, body, **kwargs):  # noqa: E501
         """describe_transit_router_attachments  # noqa: E501
 
@@ -5174,6 +5659,103 @@ 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
+
+        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)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :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_grant_rules_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_transit_router_grant_rules_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
+
+        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)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeTransitRouterGrantRulesRequest body: (required)
+        :return: DescribeTransitRouterGrantRulesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method describe_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_grant_rules`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/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='DescribeTransitRouterGrantRulesResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def describe_transit_router_multicast_domain_associations(self, body, **kwargs):  # noqa: E501
         """describe_transit_router_multicast_domain_associations  # noqa: E501
 
@@ -8472,6 +9054,103 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def modify_transit_router_grant_rule_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_grant_rule_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.modify_transit_router_grant_rule_attributes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyTransitRouterGrantRuleAttributesRequest body: (required)
+        :return: ModifyTransitRouterGrantRuleAttributesResponse
+                 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_grant_rule_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_transit_router_grant_rule_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_transit_router_grant_rule_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_grant_rule_attributes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.modify_transit_router_grant_rule_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyTransitRouterGrantRuleAttributesRequest body: (required)
+        :return: ModifyTransitRouterGrantRuleAttributesResponse
+                 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_grant_rule_attributes" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_transit_router_grant_rule_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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ModifyTransitRouterGrantRuleAttributes/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='ModifyTransitRouterGrantRuleAttributesResponse',  # 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_multicast_domain_attributes(self, body, **kwargs):  # noqa: E501
         """modify_transit_router_multicast_domain_attributes  # noqa: E501
 
@@ -9442,6 +10121,103 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def modify_transit_router_traffic_qos_queue_entry_attributes(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_traffic_qos_queue_entry_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_traffic_qos_queue_entry_attributes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyTransitRouterTrafficQosQueueEntryAttributesRequest body: (required)
+        :return: ModifyTransitRouterTrafficQosQueueEntryAttributesResponse
+                 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_traffic_qos_queue_entry_attributes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_transit_router_traffic_qos_queue_entry_attributes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_transit_router_traffic_qos_queue_entry_attributes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_transit_router_traffic_qos_queue_entry_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_traffic_qos_queue_entry_attributes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyTransitRouterTrafficQosQueueEntryAttributesRequest body: (required)
+        :return: ModifyTransitRouterTrafficQosQueueEntryAttributesResponse
+                 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_traffic_qos_queue_entry_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_traffic_qos_queue_entry_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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ModifyTransitRouterTrafficQosQueueEntryAttributes/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='ModifyTransitRouterTrafficQosQueueEntryAttributesResponse',  # 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_traffic_qos_queue_policy_association(self, body, **kwargs):  # noqa: E501
         """modify_transit_router_traffic_qos_queue_policy_association  # noqa: E501
 
@@ -9830,6 +10606,200 @@ class TRANSITROUTERApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def reject_shared_transit_router(self, body, **kwargs):  # noqa: E501
+        """reject_shared_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.reject_shared_transit_router(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param RejectSharedTransitRouterRequest body: (required)
+        :return: RejectSharedTransitRouterResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.reject_shared_transit_router_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.reject_shared_transit_router_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def reject_shared_transit_router_with_http_info(self, body, **kwargs):  # noqa: E501
+        """reject_shared_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.reject_shared_transit_router_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param RejectSharedTransitRouterRequest body: (required)
+        :return: RejectSharedTransitRouterResponse
+                 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 reject_shared_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 `reject_shared_transit_router`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/RejectSharedTransitRouter/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='RejectSharedTransitRouterResponse',  # 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 reject_transit_router_peer_attachment(self, body, **kwargs):  # noqa: E501
+        """reject_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.reject_transit_router_peer_attachment(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param RejectTransitRouterPeerAttachmentRequest body: (required)
+        :return: RejectTransitRouterPeerAttachmentResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.reject_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.reject_transit_router_peer_attachment_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def reject_transit_router_peer_attachment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """reject_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.reject_transit_router_peer_attachment_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param RejectTransitRouterPeerAttachmentRequest body: (required)
+        :return: RejectTransitRouterPeerAttachmentResponse
+                 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 reject_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 `reject_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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/RejectTransitRouterPeerAttachment/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='RejectTransitRouterPeerAttachmentResponse',  # 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 renew_transit_router_bandwidth_package(self, body, **kwargs):  # noqa: E501
         """renew_transit_router_bandwidth_package  # noqa: E501