volcengine-python-sdk 4.0.21__py2.py3-none-any.whl → 4.0.22__py2.py3-none-any.whl

volcenginesdkvedbm/api/vedbm_api.py

@@ -324,6 +324,200 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def cancel_schedule_events(self, body, **kwargs):  # noqa: E501
+        """cancel_schedule_events  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.cancel_schedule_events(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CancelScheduleEventsRequest body: (required)
+        :return: CancelScheduleEventsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.cancel_schedule_events_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.cancel_schedule_events_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def cancel_schedule_events_with_http_info(self, body, **kwargs):  # noqa: E501
+        """cancel_schedule_events  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.cancel_schedule_events_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CancelScheduleEventsRequest body: (required)
+        :return: CancelScheduleEventsResponse
+                 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 cancel_schedule_events" % 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 `cancel_schedule_events`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/CancelScheduleEvents/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='CancelScheduleEventsResponse',  # 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 change_master(self, body, **kwargs):  # noqa: E501
+        """change_master  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.change_master(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ChangeMasterRequest body: (required)
+        :return: ChangeMasterResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.change_master_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.change_master_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def change_master_with_http_info(self, body, **kwargs):  # noqa: E501
+        """change_master  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.change_master_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ChangeMasterRequest body: (required)
+        :return: ChangeMasterResponse
+                 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 change_master" % 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 `change_master`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ChangeMaster/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ChangeMasterResponse',  # 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_allow_list(self, body, **kwargs):  # noqa: E501
         """create_allow_list  # noqa: E501
 
@@ -2070,6 +2264,103 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def describe_availability_zones(self, body, **kwargs):  # noqa: E501
+        """describe_availability_zones  # 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_availability_zones(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeAvailabilityZonesRequest body: (required)
+        :return: DescribeAvailabilityZonesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_availability_zones_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_availability_zones_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_availability_zones_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_availability_zones  # 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_availability_zones_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeAvailabilityZonesRequest body: (required)
+        :return: DescribeAvailabilityZonesResponse
+                 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_availability_zones" % 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_availability_zones`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeAvailabilityZones/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeAvailabilityZonesResponse',  # 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_backup_policy(self, body, **kwargs):  # noqa: E501
         """describe_backup_policy  # noqa: E501
 
@@ -2846,38 +3137,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_db_instance_parameters(self, body, **kwargs):  # noqa: E501
-        """describe_db_instance_parameters  # noqa: E501
+    def describe_db_instance_parameter_change_history(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_parameter_change_history  # 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_db_instance_parameters(body, async_req=True)
+        >>> thread = api.describe_db_instance_parameter_change_history(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDBInstanceParametersRequest body: (required)
-        :return: DescribeDBInstanceParametersResponse
+        :param DescribeDBInstanceParameterChangeHistoryRequest body: (required)
+        :return: DescribeDBInstanceParameterChangeHistoryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_db_instance_parameters_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_db_instance_parameter_change_history_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_db_instance_parameters_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_db_instance_parameter_change_history_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_db_instance_parameters_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_db_instance_parameters  # noqa: E501
+    def describe_db_instance_parameter_change_history_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_parameter_change_history  # 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_db_instance_parameters_with_http_info(body, async_req=True)
+        >>> thread = api.describe_db_instance_parameter_change_history_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDBInstanceParametersRequest body: (required)
-        :return: DescribeDBInstanceParametersResponse
+        :param DescribeDBInstanceParameterChangeHistoryRequest body: (required)
+        :return: DescribeDBInstanceParameterChangeHistoryResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2893,7 +3184,104 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_db_instance_parameters" % key
+                    " to method describe_db_instance_parameter_change_history" % 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_db_instance_parameter_change_history`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeDBInstanceParameterChangeHistory/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeDBInstanceParameterChangeHistoryResponse',  # 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_db_instance_parameters(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_parameters  # 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_db_instance_parameters(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDBInstanceParametersRequest body: (required)
+        :return: DescribeDBInstanceParametersResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_db_instance_parameters_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_db_instance_parameters_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_db_instance_parameters_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_parameters  # 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_db_instance_parameters_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDBInstanceParametersRequest body: (required)
+        :return: DescribeDBInstanceParametersResponse
+                 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_db_instance_parameters" % key
                 )
             params[key] = val
         del params['kwargs']
@@ -2943,38 +3331,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_db_instances(self, body, **kwargs):  # noqa: E501
-        """describe_db_instances  # noqa: E501
+    def describe_db_instance_price_detail(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_price_detail  # 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_db_instances(body, async_req=True)
+        >>> thread = api.describe_db_instance_price_detail(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDBInstancesRequest body: (required)
-        :return: DescribeDBInstancesResponse
+        :param DescribeDBInstancePriceDetailRequest body: (required)
+        :return: DescribeDBInstancePriceDetailResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_db_instances_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_db_instance_price_detail_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_db_instances_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_db_instance_price_detail_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_db_instances_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_db_instances  # noqa: E501
+    def describe_db_instance_price_detail_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_price_detail  # 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_db_instances_with_http_info(body, async_req=True)
+        >>> thread = api.describe_db_instance_price_detail_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeDBInstancesRequest body: (required)
-        :return: DescribeDBInstancesResponse
+        :param DescribeDBInstancePriceDetailRequest body: (required)
+        :return: DescribeDBInstancePriceDetailResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2990,14 +3378,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_db_instances" % key
+                    " to method describe_db_instance_price_detail" % 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_db_instances`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_db_instance_price_detail`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3025,14 +3413,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeDBInstances/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/DescribeDBInstancePriceDetail/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeDBInstancesResponse',  # noqa: E501
+            response_type='DescribeDBInstancePriceDetailResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3040,38 +3428,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_parameter_template_detail(self, body, **kwargs):  # noqa: E501
-        """describe_parameter_template_detail  # noqa: E501
+    def describe_db_instance_specs(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_specs  # 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_parameter_template_detail(body, async_req=True)
+        >>> thread = api.describe_db_instance_specs(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeParameterTemplateDetailRequest body: (required)
-        :return: DescribeParameterTemplateDetailResponse
+        :param DescribeDBInstanceSpecsRequest body: (required)
+        :return: DescribeDBInstanceSpecsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_parameter_template_detail_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_db_instance_specs_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_parameter_template_detail_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_db_instance_specs_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_parameter_template_detail_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_parameter_template_detail  # noqa: E501
+    def describe_db_instance_specs_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_specs  # 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_parameter_template_detail_with_http_info(body, async_req=True)
+        >>> thread = api.describe_db_instance_specs_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeParameterTemplateDetailRequest body: (required)
-        :return: DescribeParameterTemplateDetailResponse
+        :param DescribeDBInstanceSpecsRequest body: (required)
+        :return: DescribeDBInstanceSpecsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3087,14 +3475,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_parameter_template_detail" % key
+                    " to method describe_db_instance_specs" % 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_parameter_template_detail`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_db_instance_specs`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3122,14 +3510,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeParameterTemplateDetail/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/DescribeDBInstanceSpecs/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeParameterTemplateDetailResponse',  # noqa: E501
+            response_type='DescribeDBInstanceSpecsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3137,38 +3525,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_parameter_templates(self, body, **kwargs):  # noqa: E501
-        """describe_parameter_templates  # noqa: E501
+    def describe_db_instance_version(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_version  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_parameter_templates(body, async_req=True)
+        >>> thread = api.describe_db_instance_version(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeParameterTemplatesRequest body: (required)
-        :return: DescribeParameterTemplatesResponse
+        :param DescribeDBInstanceVersionRequest body: (required)
+        :return: DescribeDBInstanceVersionResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_parameter_templates_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_db_instance_version_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_parameter_templates_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_db_instance_version_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_parameter_templates_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_parameter_templates  # noqa: E501
+    def describe_db_instance_version_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_db_instance_version  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_parameter_templates_with_http_info(body, async_req=True)
+        >>> thread = api.describe_db_instance_version_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeParameterTemplatesRequest body: (required)
-        :return: DescribeParameterTemplatesResponse
+        :param DescribeDBInstanceVersionRequest body: (required)
+        :return: DescribeDBInstanceVersionResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3184,14 +3572,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_parameter_templates" % key
+                    " to method describe_db_instance_version" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `describe_parameter_templates`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_db_instance_version`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3219,14 +3607,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeParameterTemplates/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/DescribeDBInstanceVersion/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeParameterTemplatesResponse',  # noqa: E501
+            response_type='DescribeDBInstanceVersionResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3234,38 +3622,1590 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_recoverable_time(self, body, **kwargs):  # noqa: E501
-        """describe_recoverable_time  # noqa: E501
+    def describe_db_instances(self, body, **kwargs):  # noqa: E501
+        """describe_db_instances  # 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_recoverable_time(body, async_req=True)
+        >>> thread = api.describe_db_instances(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeRecoverableTimeRequest body: (required)
-        :return: DescribeRecoverableTimeResponse
+        :param DescribeDBInstancesRequest body: (required)
+        :return: DescribeDBInstancesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.describe_recoverable_time_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_db_instances_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.describe_recoverable_time_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_db_instances_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def describe_recoverable_time_with_http_info(self, body, **kwargs):  # noqa: E501
-        """describe_recoverable_time  # noqa: E501
+    def describe_db_instances_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_db_instances  # 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_db_instances_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeDBInstancesRequest body: (required)
+        :return: DescribeDBInstancesResponse
+                 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_db_instances" % 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_db_instances`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeDBInstances/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeDBInstancesResponse',  # 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_exist_db_instance_price(self, body, **kwargs):  # noqa: E501
+        """describe_exist_db_instance_price  # 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_exist_db_instance_price(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeExistDBInstancePriceRequest body: (required)
+        :return: DescribeExistDBInstancePriceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_exist_db_instance_price_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_exist_db_instance_price_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_exist_db_instance_price_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_exist_db_instance_price  # 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_exist_db_instance_price_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeExistDBInstancePriceRequest body: (required)
+        :return: DescribeExistDBInstancePriceResponse
+                 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_exist_db_instance_price" % 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_exist_db_instance_price`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeExistDBInstancePrice/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeExistDBInstancePriceResponse',  # 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_instance_allow_lists(self, body, **kwargs):  # noqa: E501
+        """describe_instance_allow_lists  # 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_instance_allow_lists(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeInstanceAllowListsRequest body: (required)
+        :return: DescribeInstanceAllowListsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_instance_allow_lists_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_instance_allow_lists_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_instance_allow_lists_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_instance_allow_lists  # 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_instance_allow_lists_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeInstanceAllowListsRequest body: (required)
+        :return: DescribeInstanceAllowListsResponse
+                 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_instance_allow_lists" % 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_instance_allow_lists`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeInstanceAllowLists/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeInstanceAllowListsResponse',  # 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_modifiable_parameters(self, body, **kwargs):  # noqa: E501
+        """describe_modifiable_parameters  # 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_modifiable_parameters(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeModifiableParametersRequest body: (required)
+        :return: DescribeModifiableParametersResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_modifiable_parameters_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_modifiable_parameters_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_modifiable_parameters_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_modifiable_parameters  # 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_modifiable_parameters_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeModifiableParametersRequest body: (required)
+        :return: DescribeModifiableParametersResponse
+                 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_modifiable_parameters" % 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_modifiable_parameters`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeModifiableParameters/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeModifiableParametersResponse',  # 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_parameter_template_detail(self, body, **kwargs):  # noqa: E501
+        """describe_parameter_template_detail  # 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_parameter_template_detail(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeParameterTemplateDetailRequest body: (required)
+        :return: DescribeParameterTemplateDetailResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_parameter_template_detail_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_parameter_template_detail_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_parameter_template_detail_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_parameter_template_detail  # 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_parameter_template_detail_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeParameterTemplateDetailRequest body: (required)
+        :return: DescribeParameterTemplateDetailResponse
+                 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_parameter_template_detail" % 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_parameter_template_detail`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeParameterTemplateDetail/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeParameterTemplateDetailResponse',  # 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_parameter_templates(self, body, **kwargs):  # noqa: E501
+        """describe_parameter_templates  # 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_parameter_templates(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeParameterTemplatesRequest body: (required)
+        :return: DescribeParameterTemplatesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_parameter_templates_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_parameter_templates_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_parameter_templates_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_parameter_templates  # 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_parameter_templates_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeParameterTemplatesRequest body: (required)
+        :return: DescribeParameterTemplatesResponse
+                 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_parameter_templates" % 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_parameter_templates`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeParameterTemplates/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeParameterTemplatesResponse',  # 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_recoverable_time(self, body, **kwargs):  # noqa: E501
+        """describe_recoverable_time  # 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_recoverable_time(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeRecoverableTimeRequest body: (required)
+        :return: DescribeRecoverableTimeResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_recoverable_time_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_recoverable_time_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_recoverable_time_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_recoverable_time  # 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_recoverable_time_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeRecoverableTimeRequest body: (required)
+        :return: DescribeRecoverableTimeResponse
+                 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_recoverable_time" % 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_recoverable_time`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeRecoverableTime/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeRecoverableTimeResponse',  # 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_regions(self, body, **kwargs):  # noqa: E501
+        """describe_regions  # 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_regions(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeRegionsRequest body: (required)
+        :return: DescribeRegionsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_regions_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_regions_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_regions_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_regions  # 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_regions_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeRegionsRequest body: (required)
+        :return: DescribeRegionsResponse
+                 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_regions" % 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_regions`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeRegions/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeRegionsResponse',  # 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_schedule_events(self, body, **kwargs):  # noqa: E501
+        """describe_schedule_events  # 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_schedule_events(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeScheduleEventsRequest body: (required)
+        :return: DescribeScheduleEventsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_schedule_events_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_schedule_events_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_schedule_events_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_schedule_events  # 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_schedule_events_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeScheduleEventsRequest body: (required)
+        :return: DescribeScheduleEventsResponse
+                 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_schedule_events" % 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_schedule_events`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeScheduleEvents/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeScheduleEventsResponse',  # 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_storage_payable_price(self, body, **kwargs):  # noqa: E501
+        """describe_storage_payable_price  # 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_storage_payable_price(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeStoragePayablePriceRequest body: (required)
+        :return: DescribeStoragePayablePriceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.describe_storage_payable_price_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.describe_storage_payable_price_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def describe_storage_payable_price_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_storage_payable_price  # 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_storage_payable_price_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DescribeStoragePayablePriceRequest body: (required)
+        :return: DescribeStoragePayablePriceResponse
+                 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_storage_payable_price" % 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_storage_payable_price`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DescribeStoragePayablePrice/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DescribeStoragePayablePriceResponse',  # 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 disassociate_allow_list(self, body, **kwargs):  # noqa: E501
+        """disassociate_allow_list  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.disassociate_allow_list(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DisassociateAllowListRequest body: (required)
+        :return: DisassociateAllowListResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.disassociate_allow_list_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.disassociate_allow_list_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def disassociate_allow_list_with_http_info(self, body, **kwargs):  # noqa: E501
+        """disassociate_allow_list  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.disassociate_allow_list_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DisassociateAllowListRequest body: (required)
+        :return: DisassociateAllowListResponse
+                 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 disassociate_allow_list" % 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 `disassociate_allow_list`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DisassociateAllowList/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DisassociateAllowListResponse',  # 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 grant_db_account_privilege(self, body, **kwargs):  # noqa: E501
+        """grant_db_account_privilege  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.grant_db_account_privilege(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GrantDBAccountPrivilegeRequest body: (required)
+        :return: GrantDBAccountPrivilegeResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.grant_db_account_privilege_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.grant_db_account_privilege_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def grant_db_account_privilege_with_http_info(self, body, **kwargs):  # noqa: E501
+        """grant_db_account_privilege  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.grant_db_account_privilege_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GrantDBAccountPrivilegeRequest body: (required)
+        :return: GrantDBAccountPrivilegeResponse
+                 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 grant_db_account_privilege" % 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 `grant_db_account_privilege`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GrantDBAccountPrivilege/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GrantDBAccountPrivilegeResponse',  # 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_allow_list(self, body, **kwargs):  # noqa: E501
+        """modify_allow_list  # 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_allow_list(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyAllowListRequest body: (required)
+        :return: ModifyAllowListResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.modify_allow_list_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_allow_list_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_allow_list_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_allow_list  # 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_allow_list_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyAllowListRequest body: (required)
+        :return: ModifyAllowListResponse
+                 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_allow_list" % 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_allow_list`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ModifyAllowList/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ModifyAllowListResponse',  # 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_backup_policy(self, body, **kwargs):  # noqa: E501
+        """modify_backup_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.modify_backup_policy(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyBackupPolicyRequest body: (required)
+        :return: ModifyBackupPolicyResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.modify_backup_policy_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_backup_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_backup_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_backup_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.modify_backup_policy_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyBackupPolicyRequest body: (required)
+        :return: ModifyBackupPolicyResponse
+                 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_backup_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 `modify_backup_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
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ModifyBackupPolicy/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ModifyBackupPolicyResponse',  # 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_cross_region_backup_policy(self, body, **kwargs):  # noqa: E501
+        """modify_cross_region_backup_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.modify_cross_region_backup_policy(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyCrossRegionBackupPolicyRequest body: (required)
+        :return: ModifyCrossRegionBackupPolicyResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.modify_cross_region_backup_policy_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_cross_region_backup_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_cross_region_backup_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_cross_region_backup_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.modify_cross_region_backup_policy_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyCrossRegionBackupPolicyRequest body: (required)
+        :return: ModifyCrossRegionBackupPolicyResponse
+                 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_cross_region_backup_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 `modify_cross_region_backup_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
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ModifyCrossRegionBackupPolicy/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ModifyCrossRegionBackupPolicyResponse',  # 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_database_description(self, body, **kwargs):  # noqa: E501
+        """modify_database_description  # 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_database_description(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyDatabaseDescriptionRequest body: (required)
+        :return: ModifyDatabaseDescriptionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.modify_database_description_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_database_description_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_database_description_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_database_description  # 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_database_description_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyDatabaseDescriptionRequest body: (required)
+        :return: ModifyDatabaseDescriptionResponse
+                 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_database_description" % 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_database_description`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ModifyDatabaseDescription/2022-01-01/vedbm/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ModifyDatabaseDescriptionResponse',  # 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_db_account_description(self, body, **kwargs):  # noqa: E501
+        """modify_db_account_description  # 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_db_account_description(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModifyDBAccountDescriptionRequest body: (required)
+        :return: ModifyDBAccountDescriptionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.modify_db_account_description_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.modify_db_account_description_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def modify_db_account_description_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_account_description  # 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_recoverable_time_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_account_description_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DescribeRecoverableTimeRequest body: (required)
-        :return: DescribeRecoverableTimeResponse
+        :param ModifyDBAccountDescriptionRequest body: (required)
+        :return: ModifyDBAccountDescriptionResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3281,14 +5221,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method describe_recoverable_time" % key
+                    " to method modify_db_account_description" % 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_recoverable_time`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_account_description`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3316,14 +5256,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DescribeRecoverableTime/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBAccountDescription/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DescribeRecoverableTimeResponse',  # noqa: E501
+            response_type='ModifyDBAccountDescriptionResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3331,38 +5271,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def disassociate_allow_list(self, body, **kwargs):  # noqa: E501
-        """disassociate_allow_list  # noqa: E501
+    def modify_db_endpoint(self, body, **kwargs):  # noqa: E501
+        """modify_db_endpoint  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.disassociate_allow_list(body, async_req=True)
+        >>> thread = api.modify_db_endpoint(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DisassociateAllowListRequest body: (required)
-        :return: DisassociateAllowListResponse
+        :param ModifyDBEndpointRequest body: (required)
+        :return: ModifyDBEndpointResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.disassociate_allow_list_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_endpoint_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.disassociate_allow_list_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_endpoint_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def disassociate_allow_list_with_http_info(self, body, **kwargs):  # noqa: E501
-        """disassociate_allow_list  # noqa: E501
+    def modify_db_endpoint_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_endpoint  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.disassociate_allow_list_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_endpoint_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DisassociateAllowListRequest body: (required)
-        :return: DisassociateAllowListResponse
+        :param ModifyDBEndpointRequest body: (required)
+        :return: ModifyDBEndpointResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3378,14 +5318,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method disassociate_allow_list" % key
+                    " to method modify_db_endpoint" % 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 `disassociate_allow_list`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_endpoint`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3413,14 +5353,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DisassociateAllowList/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBEndpoint/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DisassociateAllowListResponse',  # noqa: E501
+            response_type='ModifyDBEndpointResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3428,38 +5368,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def grant_db_account_privilege(self, body, **kwargs):  # noqa: E501
-        """grant_db_account_privilege  # noqa: E501
+    def modify_db_endpoint_address(self, body, **kwargs):  # noqa: E501
+        """modify_db_endpoint_address  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.grant_db_account_privilege(body, async_req=True)
+        >>> thread = api.modify_db_endpoint_address(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GrantDBAccountPrivilegeRequest body: (required)
-        :return: GrantDBAccountPrivilegeResponse
+        :param ModifyDBEndpointAddressRequest body: (required)
+        :return: ModifyDBEndpointAddressResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.grant_db_account_privilege_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_endpoint_address_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.grant_db_account_privilege_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_endpoint_address_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def grant_db_account_privilege_with_http_info(self, body, **kwargs):  # noqa: E501
-        """grant_db_account_privilege  # noqa: E501
+    def modify_db_endpoint_address_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_endpoint_address  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.grant_db_account_privilege_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_endpoint_address_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GrantDBAccountPrivilegeRequest body: (required)
-        :return: GrantDBAccountPrivilegeResponse
+        :param ModifyDBEndpointAddressRequest body: (required)
+        :return: ModifyDBEndpointAddressResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3475,14 +5415,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method grant_db_account_privilege" % key
+                    " to method modify_db_endpoint_address" % 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 `grant_db_account_privilege`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_endpoint_address`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3510,14 +5450,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GrantDBAccountPrivilege/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBEndpointAddress/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GrantDBAccountPrivilegeResponse',  # noqa: E501
+            response_type='ModifyDBEndpointAddressResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3525,38 +5465,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_allow_list(self, body, **kwargs):  # noqa: E501
-        """modify_allow_list  # noqa: E501
+    def modify_db_endpoint_dns(self, body, **kwargs):  # noqa: E501
+        """modify_db_endpoint_dns  # 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_allow_list(body, async_req=True)
+        >>> thread = api.modify_db_endpoint_dns(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyAllowListRequest body: (required)
-        :return: ModifyAllowListResponse
+        :param ModifyDBEndpointDNSRequest body: (required)
+        :return: ModifyDBEndpointDNSResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_allow_list_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_endpoint_dns_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_allow_list_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_endpoint_dns_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_allow_list_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_allow_list  # noqa: E501
+    def modify_db_endpoint_dns_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_endpoint_dns  # 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_allow_list_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_endpoint_dns_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyAllowListRequest body: (required)
-        :return: ModifyAllowListResponse
+        :param ModifyDBEndpointDNSRequest body: (required)
+        :return: ModifyDBEndpointDNSResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3572,14 +5512,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_allow_list" % key
+                    " to method modify_db_endpoint_dns" % 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_allow_list`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_endpoint_dns`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3607,14 +5547,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyAllowList/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBEndpointDNS/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyAllowListResponse',  # noqa: E501
+            response_type='ModifyDBEndpointDNSResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3622,38 +5562,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_backup_policy(self, body, **kwargs):  # noqa: E501
-        """modify_backup_policy  # noqa: E501
+    def modify_db_instance_charge_type(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_charge_type  # 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_backup_policy(body, async_req=True)
+        >>> thread = api.modify_db_instance_charge_type(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyBackupPolicyRequest body: (required)
-        :return: ModifyBackupPolicyResponse
+        :param ModifyDBInstanceChargeTypeRequest body: (required)
+        :return: ModifyDBInstanceChargeTypeResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_backup_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_instance_charge_type_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_backup_policy_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_instance_charge_type_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_backup_policy_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_backup_policy  # noqa: E501
+    def modify_db_instance_charge_type_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_charge_type  # 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_backup_policy_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_instance_charge_type_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyBackupPolicyRequest body: (required)
-        :return: ModifyBackupPolicyResponse
+        :param ModifyDBInstanceChargeTypeRequest body: (required)
+        :return: ModifyDBInstanceChargeTypeResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3669,14 +5609,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_backup_policy" % key
+                    " to method modify_db_instance_charge_type" % 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_backup_policy`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_instance_charge_type`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3704,14 +5644,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyBackupPolicy/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBInstanceChargeType/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyBackupPolicyResponse',  # noqa: E501
+            response_type='ModifyDBInstanceChargeTypeResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3719,38 +5659,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_cross_region_backup_policy(self, body, **kwargs):  # noqa: E501
-        """modify_cross_region_backup_policy  # noqa: E501
+    def modify_db_instance_deletion_protection_policy(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_deletion_protection_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.modify_cross_region_backup_policy(body, async_req=True)
+        >>> thread = api.modify_db_instance_deletion_protection_policy(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyCrossRegionBackupPolicyRequest body: (required)
-        :return: ModifyCrossRegionBackupPolicyResponse
+        :param ModifyDBInstanceDeletionProtectionPolicyRequest body: (required)
+        :return: ModifyDBInstanceDeletionProtectionPolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_cross_region_backup_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_instance_deletion_protection_policy_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_cross_region_backup_policy_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_instance_deletion_protection_policy_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_cross_region_backup_policy_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_cross_region_backup_policy  # noqa: E501
+    def modify_db_instance_deletion_protection_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_deletion_protection_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.modify_cross_region_backup_policy_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_instance_deletion_protection_policy_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyCrossRegionBackupPolicyRequest body: (required)
-        :return: ModifyCrossRegionBackupPolicyResponse
+        :param ModifyDBInstanceDeletionProtectionPolicyRequest body: (required)
+        :return: ModifyDBInstanceDeletionProtectionPolicyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3766,14 +5706,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_cross_region_backup_policy" % key
+                    " to method modify_db_instance_deletion_protection_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 `modify_cross_region_backup_policy`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_instance_deletion_protection_policy`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3801,14 +5741,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyCrossRegionBackupPolicy/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBInstanceDeletionProtectionPolicy/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyCrossRegionBackupPolicyResponse',  # noqa: E501
+            response_type='ModifyDBInstanceDeletionProtectionPolicyResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3816,38 +5756,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_database_description(self, body, **kwargs):  # noqa: E501
-        """modify_database_description  # noqa: E501
+    def modify_db_instance_maintenance_window(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_maintenance_window  # 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_database_description(body, async_req=True)
+        >>> thread = api.modify_db_instance_maintenance_window(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDatabaseDescriptionRequest body: (required)
-        :return: ModifyDatabaseDescriptionResponse
+        :param ModifyDBInstanceMaintenanceWindowRequest body: (required)
+        :return: ModifyDBInstanceMaintenanceWindowResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_database_description_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_instance_maintenance_window_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_database_description_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_instance_maintenance_window_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_database_description_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_database_description  # noqa: E501
+    def modify_db_instance_maintenance_window_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_maintenance_window  # 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_database_description_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_instance_maintenance_window_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDatabaseDescriptionRequest body: (required)
-        :return: ModifyDatabaseDescriptionResponse
+        :param ModifyDBInstanceMaintenanceWindowRequest body: (required)
+        :return: ModifyDBInstanceMaintenanceWindowResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3863,14 +5803,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_database_description" % key
+                    " to method modify_db_instance_maintenance_window" % 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_database_description`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_instance_maintenance_window`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3898,14 +5838,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDatabaseDescription/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBInstanceMaintenanceWindow/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDatabaseDescriptionResponse',  # noqa: E501
+            response_type='ModifyDBInstanceMaintenanceWindowResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3913,38 +5853,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_db_account_description(self, body, **kwargs):  # noqa: E501
-        """modify_db_account_description  # noqa: E501
+    def modify_db_instance_name(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_name  # 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_db_account_description(body, async_req=True)
+        >>> thread = api.modify_db_instance_name(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBAccountDescriptionRequest body: (required)
-        :return: ModifyDBAccountDescriptionResponse
+        :param ModifyDBInstanceNameRequest body: (required)
+        :return: ModifyDBInstanceNameResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_db_account_description_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_instance_name_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_db_account_description_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_instance_name_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_db_account_description_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_db_account_description  # noqa: E501
+    def modify_db_instance_name_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_name  # 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_db_account_description_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_instance_name_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBAccountDescriptionRequest body: (required)
-        :return: ModifyDBAccountDescriptionResponse
+        :param ModifyDBInstanceNameRequest body: (required)
+        :return: ModifyDBInstanceNameResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -3960,14 +5900,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_db_account_description" % key
+                    " to method modify_db_instance_name" % 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_db_account_description`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_instance_name`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3995,14 +5935,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDBAccountDescription/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBInstanceName/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDBAccountDescriptionResponse',  # noqa: E501
+            response_type='ModifyDBInstanceNameResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4010,38 +5950,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_db_endpoint(self, body, **kwargs):  # noqa: E501
-        """modify_db_endpoint  # noqa: E501
+    def modify_db_instance_parameters(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_parameters  # 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_db_endpoint(body, async_req=True)
+        >>> thread = api.modify_db_instance_parameters(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBEndpointRequest body: (required)
-        :return: ModifyDBEndpointResponse
+        :param ModifyDBInstanceParametersRequest body: (required)
+        :return: ModifyDBInstanceParametersResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_db_endpoint_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_instance_parameters_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_db_endpoint_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_instance_parameters_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_db_endpoint_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_db_endpoint  # noqa: E501
+    def modify_db_instance_parameters_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_parameters  # 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_db_endpoint_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_instance_parameters_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBEndpointRequest body: (required)
-        :return: ModifyDBEndpointResponse
+        :param ModifyDBInstanceParametersRequest body: (required)
+        :return: ModifyDBInstanceParametersResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4057,14 +5997,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_db_endpoint" % key
+                    " to method modify_db_instance_parameters" % 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_db_endpoint`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_instance_parameters`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4092,14 +6032,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDBEndpoint/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBInstanceParameters/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDBEndpointResponse',  # noqa: E501
+            response_type='ModifyDBInstanceParametersResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4107,38 +6047,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_db_instance_name(self, body, **kwargs):  # noqa: E501
-        """modify_db_instance_name  # noqa: E501
+    def modify_db_instance_spec(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_spec  # 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_db_instance_name(body, async_req=True)
+        >>> thread = api.modify_db_instance_spec(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBInstanceNameRequest body: (required)
-        :return: ModifyDBInstanceNameResponse
+        :param ModifyDBInstanceSpecRequest body: (required)
+        :return: ModifyDBInstanceSpecResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_db_instance_name_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_instance_spec_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_db_instance_name_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_instance_spec_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_db_instance_name_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_db_instance_name  # noqa: E501
+    def modify_db_instance_spec_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_instance_spec  # 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_db_instance_name_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_instance_spec_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBInstanceNameRequest body: (required)
-        :return: ModifyDBInstanceNameResponse
+        :param ModifyDBInstanceSpecRequest body: (required)
+        :return: ModifyDBInstanceSpecResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4154,14 +6094,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_db_instance_name" % key
+                    " to method modify_db_instance_spec" % 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_db_instance_name`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_instance_spec`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4189,14 +6129,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDBInstanceName/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBInstanceSpec/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDBInstanceNameResponse',  # noqa: E501
+            response_type='ModifyDBInstanceSpecResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4204,38 +6144,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_db_instance_parameters(self, body, **kwargs):  # noqa: E501
-        """modify_db_instance_parameters  # noqa: E501
+    def modify_db_node_config(self, body, **kwargs):  # noqa: E501
+        """modify_db_node_config  # 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_db_instance_parameters(body, async_req=True)
+        >>> thread = api.modify_db_node_config(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBInstanceParametersRequest body: (required)
-        :return: ModifyDBInstanceParametersResponse
+        :param ModifyDBNodeConfigRequest body: (required)
+        :return: ModifyDBNodeConfigResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_db_instance_parameters_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_db_node_config_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_db_instance_parameters_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_db_node_config_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_db_instance_parameters_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_db_instance_parameters  # noqa: E501
+    def modify_db_node_config_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_db_node_config  # 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_db_instance_parameters_with_http_info(body, async_req=True)
+        >>> thread = api.modify_db_node_config_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBInstanceParametersRequest body: (required)
-        :return: ModifyDBInstanceParametersResponse
+        :param ModifyDBNodeConfigRequest body: (required)
+        :return: ModifyDBNodeConfigResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4251,14 +6191,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_db_instance_parameters" % key
+                    " to method modify_db_node_config" % 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_db_instance_parameters`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_db_node_config`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4286,14 +6226,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDBInstanceParameters/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyDBNodeConfig/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDBInstanceParametersResponse',  # noqa: E501
+            response_type='ModifyDBNodeConfigResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -4301,38 +6241,38 @@ class VEDBMApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def modify_db_instance_spec(self, body, **kwargs):  # noqa: E501
-        """modify_db_instance_spec  # noqa: E501
+    def modify_schedule_events(self, body, **kwargs):  # noqa: E501
+        """modify_schedule_events  # 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_db_instance_spec(body, async_req=True)
+        >>> thread = api.modify_schedule_events(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBInstanceSpecRequest body: (required)
-        :return: ModifyDBInstanceSpecResponse
+        :param ModifyScheduleEventsRequest body: (required)
+        :return: ModifyScheduleEventsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.modify_db_instance_spec_with_http_info(body, **kwargs)  # noqa: E501
+            return self.modify_schedule_events_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.modify_db_instance_spec_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.modify_schedule_events_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def modify_db_instance_spec_with_http_info(self, body, **kwargs):  # noqa: E501
-        """modify_db_instance_spec  # noqa: E501
+    def modify_schedule_events_with_http_info(self, body, **kwargs):  # noqa: E501
+        """modify_schedule_events  # 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_db_instance_spec_with_http_info(body, async_req=True)
+        >>> thread = api.modify_schedule_events_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ModifyDBInstanceSpecRequest body: (required)
-        :return: ModifyDBInstanceSpecResponse
+        :param ModifyScheduleEventsRequest body: (required)
+        :return: ModifyScheduleEventsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -4348,14 +6288,14 @@ class VEDBMApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method modify_db_instance_spec" % key
+                    " to method modify_schedule_events" % 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_db_instance_spec`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `modify_schedule_events`")  # noqa: E501
 
         collection_formats = {}
 
@@ -4383,14 +6323,14 @@ class VEDBMApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ModifyDBInstanceSpec/2022-01-01/vedbm/post/application_json/', 'POST',
+            '/ModifyScheduleEvents/2022-01-01/vedbm/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ModifyDBInstanceSpecResponse',  # noqa: E501
+            response_type='ModifyScheduleEventsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),