byteplus-python-sdk-v2 3.0.43__py2.py3-none-any.whl → 3.0.45__py2.py3-none-any.whl

byteplussdkvke/api/vke_api.py

@@ -33,6 +33,103 @@ class VKEApi(object):
             api_client = byteplussdkcore.ApiClient()
         self.api_client = api_client
 
+    def binding_remedy_config(self, body, **kwargs):  # noqa: E501
+        """binding_remedy_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.binding_remedy_config(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param BindingRemedyConfigRequest body: (required)
+        :return: BindingRemedyConfigResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.binding_remedy_config_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.binding_remedy_config_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def binding_remedy_config_with_http_info(self, body, **kwargs):  # noqa: E501
+        """binding_remedy_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.binding_remedy_config_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param BindingRemedyConfigRequest body: (required)
+        :return: BindingRemedyConfigResponse
+                 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 binding_remedy_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 `binding_remedy_config`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/BindingRemedyConfig/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='BindingRemedyConfigResponse',  # 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_addon(self, body, **kwargs):  # noqa: E501
         """create_addon  # noqa: E501
 
@@ -712,6 +809,103 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def create_snapshot(self, body, **kwargs):  # noqa: E501
+        """create_snapshot  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.create_snapshot(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateSnapshotRequest body: (required)
+        :return: CreateSnapshotResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.create_snapshot_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.create_snapshot_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def create_snapshot_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_snapshot  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.create_snapshot_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateSnapshotRequest body: (required)
+        :return: CreateSnapshotResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method create_snapshot" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_snapshot`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/CreateSnapshot/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='CreateSnapshotResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def delete_addon(self, body, **kwargs):  # noqa: E501
         """delete_addon  # noqa: E501
 
@@ -1294,38 +1488,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def exec_container_image_commitment(self, body, **kwargs):  # noqa: E501
-        """exec_container_image_commitment  # noqa: E501
+    def delete_snapshot(self, body, **kwargs):  # noqa: E501
+        """delete_snapshot  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.exec_container_image_commitment(body, async_req=True)
+        >>> thread = api.delete_snapshot(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ExecContainerImageCommitmentRequest body: (required)
-        :return: ExecContainerImageCommitmentResponse
+        :param DeleteSnapshotRequest body: (required)
+        :return: DeleteSnapshotResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.exec_container_image_commitment_with_http_info(body, **kwargs)  # noqa: E501
+            return self.delete_snapshot_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.exec_container_image_commitment_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.delete_snapshot_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def exec_container_image_commitment_with_http_info(self, body, **kwargs):  # noqa: E501
-        """exec_container_image_commitment  # noqa: E501
+    def delete_snapshot_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_snapshot  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.exec_container_image_commitment_with_http_info(body, async_req=True)
+        >>> thread = api.delete_snapshot_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ExecContainerImageCommitmentRequest body: (required)
-        :return: ExecContainerImageCommitmentResponse
+        :param DeleteSnapshotRequest body: (required)
+        :return: DeleteSnapshotResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1341,14 +1535,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method exec_container_image_commitment" % key
+                    " to method delete_snapshot" % 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 `exec_container_image_commitment`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_snapshot`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1376,14 +1570,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ExecContainerImageCommitment/2022-05-12/vke/post/application_json/', 'POST',
+            '/DeleteSnapshot/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ExecContainerImageCommitmentResponse',  # noqa: E501
+            response_type='DeleteSnapshotResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1391,38 +1585,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def forward_kubernetes_api(self, body, **kwargs):  # noqa: E501
-        """forward_kubernetes_api  # noqa: E501
+    def describe_container_image_commitments(self, body, **kwargs):  # noqa: E501
+        """describe_container_image_commitments  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.forward_kubernetes_api(body, async_req=True)
+        >>> thread = api.describe_container_image_commitments(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ForwardKubernetesApiRequest body: (required)
-        :return: ForwardKubernetesApiResponse
+        :param DescribeContainerImageCommitmentsRequest body: (required)
+        :return: DescribeContainerImageCommitmentsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.forward_kubernetes_api_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_container_image_commitments_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.forward_kubernetes_api_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_container_image_commitments_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def forward_kubernetes_api_with_http_info(self, body, **kwargs):  # noqa: E501
-        """forward_kubernetes_api  # noqa: E501
+    def describe_container_image_commitments_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_container_image_commitments  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.forward_kubernetes_api_with_http_info(body, async_req=True)
+        >>> thread = api.describe_container_image_commitments_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ForwardKubernetesApiRequest body: (required)
-        :return: ForwardKubernetesApiResponse
+        :param DescribeContainerImageCommitmentsRequest body: (required)
+        :return: DescribeContainerImageCommitmentsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1438,14 +1632,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method forward_kubernetes_api" % key
+                    " to method describe_container_image_commitments" % 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 `forward_kubernetes_api`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_container_image_commitments`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1473,14 +1667,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ForwardKubernetesApi/2022-05-12/vke/post/application_json/', 'POST',
+            '/DescribeContainerImageCommitments/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ForwardKubernetesApiResponse',  # noqa: E501
+            response_type='DescribeContainerImageCommitmentsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1488,38 +1682,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_global_default_delete_option(self, body, **kwargs):  # noqa: E501
-        """get_global_default_delete_option  # noqa: E501
+    def describe_snapshots(self, body, **kwargs):  # noqa: E501
+        """describe_snapshots  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_global_default_delete_option(body, async_req=True)
+        >>> thread = api.describe_snapshots(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetGlobalDefaultDeleteOptionRequest body: (required)
-        :return: GetGlobalDefaultDeleteOptionResponse
+        :param DescribeSnapshotsRequest body: (required)
+        :return: DescribeSnapshotsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.get_global_default_delete_option_with_http_info(body, **kwargs)  # noqa: E501
+            return self.describe_snapshots_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.get_global_default_delete_option_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.describe_snapshots_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def get_global_default_delete_option_with_http_info(self, body, **kwargs):  # noqa: E501
-        """get_global_default_delete_option  # noqa: E501
+    def describe_snapshots_with_http_info(self, body, **kwargs):  # noqa: E501
+        """describe_snapshots  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_global_default_delete_option_with_http_info(body, async_req=True)
+        >>> thread = api.describe_snapshots_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GetGlobalDefaultDeleteOptionRequest body: (required)
-        :return: GetGlobalDefaultDeleteOptionResponse
+        :param DescribeSnapshotsRequest body: (required)
+        :return: DescribeSnapshotsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1535,14 +1729,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_global_default_delete_option" % key
+                    " to method describe_snapshots" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `get_global_default_delete_option`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `describe_snapshots`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1570,14 +1764,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GetGlobalDefaultDeleteOption/2022-05-12/vke/post/application_json/', 'POST',
+            '/DescribeSnapshots/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GetGlobalDefaultDeleteOptionResponse',  # noqa: E501
+            response_type='DescribeSnapshotsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1585,38 +1779,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def grant_permission(self, body, **kwargs):  # noqa: E501
-        """grant_permission  # noqa: E501
+    def exec_container_image_commitment(self, body, **kwargs):  # noqa: E501
+        """exec_container_image_commitment  # 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_permission(body, async_req=True)
+        >>> thread = api.exec_container_image_commitment(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GrantPermissionRequest body: (required)
-        :return: GrantPermissionResponse
+        :param ExecContainerImageCommitmentRequest body: (required)
+        :return: ExecContainerImageCommitmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.grant_permission_with_http_info(body, **kwargs)  # noqa: E501
+            return self.exec_container_image_commitment_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.grant_permission_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.exec_container_image_commitment_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def grant_permission_with_http_info(self, body, **kwargs):  # noqa: E501
-        """grant_permission  # noqa: E501
+    def exec_container_image_commitment_with_http_info(self, body, **kwargs):  # noqa: E501
+        """exec_container_image_commitment  # 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_permission_with_http_info(body, async_req=True)
+        >>> thread = api.exec_container_image_commitment_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param GrantPermissionRequest body: (required)
-        :return: GrantPermissionResponse
+        :param ExecContainerImageCommitmentRequest body: (required)
+        :return: ExecContainerImageCommitmentResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1632,14 +1826,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method grant_permission" % key
+                    " to method exec_container_image_commitment" % 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_permission`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `exec_container_image_commitment`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1667,14 +1861,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/GrantPermission/2022-05-12/vke/post/application_json/', 'POST',
+            '/ExecContainerImageCommitment/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='GrantPermissionResponse',  # noqa: E501
+            response_type='ExecContainerImageCommitmentResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1682,25 +1876,316 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_addons(self, body, **kwargs):  # noqa: E501
-        """list_addons  # noqa: E501
+    def forward_kubernetes_api(self, body, **kwargs):  # noqa: E501
+        """forward_kubernetes_api  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_addons(body, async_req=True)
+        >>> thread = api.forward_kubernetes_api(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListAddonsRequest body: (required)
-        :return: ListAddonsResponse
+        :param ForwardKubernetesApiRequest body: (required)
+        :return: ForwardKubernetesApiResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_addons_with_http_info(body, **kwargs)  # noqa: E501
+            return self.forward_kubernetes_api_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_addons_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.forward_kubernetes_api_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def forward_kubernetes_api_with_http_info(self, body, **kwargs):  # noqa: E501
+        """forward_kubernetes_api  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.forward_kubernetes_api_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ForwardKubernetesApiRequest body: (required)
+        :return: ForwardKubernetesApiResponse
+                 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 forward_kubernetes_api" % 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 `forward_kubernetes_api`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ForwardKubernetesApi/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ForwardKubernetesApiResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def get_global_default_delete_option(self, body, **kwargs):  # noqa: E501
+        """get_global_default_delete_option  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_global_default_delete_option(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetGlobalDefaultDeleteOptionRequest body: (required)
+        :return: GetGlobalDefaultDeleteOptionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.get_global_default_delete_option_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.get_global_default_delete_option_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def get_global_default_delete_option_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_global_default_delete_option  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_global_default_delete_option_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetGlobalDefaultDeleteOptionRequest body: (required)
+        :return: GetGlobalDefaultDeleteOptionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_global_default_delete_option" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `get_global_default_delete_option`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GetGlobalDefaultDeleteOption/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GetGlobalDefaultDeleteOptionResponse',  # 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_permission(self, body, **kwargs):  # noqa: E501
+        """grant_permission  # 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_permission(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GrantPermissionRequest body: (required)
+        :return: GrantPermissionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.grant_permission_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.grant_permission_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def grant_permission_with_http_info(self, body, **kwargs):  # noqa: E501
+        """grant_permission  # 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_permission_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GrantPermissionRequest body: (required)
+        :return: GrantPermissionResponse
+                 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_permission" % 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_permission`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GrantPermission/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GrantPermissionResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_addons(self, body, **kwargs):  # noqa: E501
+        """list_addons  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_addons(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListAddonsRequest body: (required)
+        :return: ListAddonsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_addons_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_addons_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
     def list_addons_with_http_info(self, body, **kwargs):  # noqa: E501
@@ -1708,12 +2193,303 @@ class VKEApi(object):
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_addons_with_http_info(body, async_req=True)
+        >>> thread = api.list_addons_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListAddonsRequest body: (required)
+        :return: ListAddonsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method list_addons" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_addons`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListAddons/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListAddonsResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_clusters(self, body, **kwargs):  # noqa: E501
+        """list_clusters  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_clusters(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListClustersRequest body: (required)
+        :return: ListClustersResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_clusters_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_clusters_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_clusters_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_clusters  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_clusters_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListClustersRequest body: (required)
+        :return: ListClustersResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method list_clusters" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_clusters`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListClusters/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListClustersResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_instance_type_labels(self, body, **kwargs):  # noqa: E501
+        """list_instance_type_labels  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_instance_type_labels(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListInstanceTypeLabelsRequest body: (required)
+        :return: ListInstanceTypeLabelsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_instance_type_labels_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_instance_type_labels_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_instance_type_labels_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_instance_type_labels  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_instance_type_labels_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListInstanceTypeLabelsRequest body: (required)
+        :return: ListInstanceTypeLabelsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method list_instance_type_labels" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_instance_type_labels`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListInstanceTypeLabels/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListInstanceTypeLabelsResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_kubeconfigs(self, body, **kwargs):  # noqa: E501
+        """list_kubeconfigs  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_kubeconfigs(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListAddonsRequest body: (required)
-        :return: ListAddonsResponse
+        :param ListKubeconfigsRequest body: (required)
+        :return: ListKubeconfigsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_kubeconfigs_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_kubeconfigs_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_kubeconfigs_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_kubeconfigs  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_kubeconfigs_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListKubeconfigsRequest body: (required)
+        :return: ListKubeconfigsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1729,14 +2505,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_addons" % key
+                    " to method list_kubeconfigs" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_addons`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_kubeconfigs`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1764,14 +2540,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListAddons/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListKubeconfigs/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListAddonsResponse',  # noqa: E501
+            response_type='ListKubeconfigsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1779,38 +2555,232 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_clusters(self, body, **kwargs):  # noqa: E501
-        """list_clusters  # noqa: E501
+    def list_node_pools(self, body, **kwargs):  # noqa: E501
+        """list_node_pools  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_clusters(body, async_req=True)
+        >>> thread = api.list_node_pools(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListClustersRequest body: (required)
-        :return: ListClustersResponse
+        :param ListNodePoolsRequest body: (required)
+        :return: ListNodePoolsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_clusters_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_node_pools_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_clusters_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_node_pools_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_clusters_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_clusters  # noqa: E501
+    def list_node_pools_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_node_pools  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_node_pools_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListNodePoolsRequest body: (required)
+        :return: ListNodePoolsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method list_node_pools" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_node_pools`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListNodePools/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListNodePoolsResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_nodes(self, body, **kwargs):  # noqa: E501
+        """list_nodes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_nodes(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListNodesRequest body: (required)
+        :return: ListNodesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_nodes_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_nodes_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_nodes_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_nodes  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_nodes_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListNodesRequest body: (required)
+        :return: ListNodesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method list_nodes" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_nodes`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListNodes/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListNodesResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def list_permissions(self, body, **kwargs):  # noqa: E501
+        """list_permissions  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.list_permissions(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListPermissionsRequest body: (required)
+        :return: ListPermissionsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_permissions_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_permissions_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_permissions_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_permissions  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_clusters_with_http_info(body, async_req=True)
+        >>> thread = api.list_permissions_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListClustersRequest body: (required)
-        :return: ListClustersResponse
+        :param ListPermissionsRequest body: (required)
+        :return: ListPermissionsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1826,14 +2796,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_clusters" % key
+                    " to method list_permissions" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_clusters`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_permissions`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1861,14 +2831,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListClusters/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListPermissions/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListClustersResponse',  # noqa: E501
+            response_type='ListPermissionsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1876,38 +2846,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_kubeconfigs(self, body, **kwargs):  # noqa: E501
-        """list_kubeconfigs  # noqa: E501
+    def list_remedy_configs(self, body, **kwargs):  # noqa: E501
+        """list_remedy_configs  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_kubeconfigs(body, async_req=True)
+        >>> thread = api.list_remedy_configs(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListKubeconfigsRequest body: (required)
-        :return: ListKubeconfigsResponse
+        :param ListRemedyConfigsRequest body: (required)
+        :return: ListRemedyConfigsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_kubeconfigs_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_remedy_configs_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_kubeconfigs_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_remedy_configs_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_kubeconfigs_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_kubeconfigs  # noqa: E501
+    def list_remedy_configs_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_remedy_configs  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_kubeconfigs_with_http_info(body, async_req=True)
+        >>> thread = api.list_remedy_configs_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListKubeconfigsRequest body: (required)
-        :return: ListKubeconfigsResponse
+        :param ListRemedyConfigsRequest body: (required)
+        :return: ListRemedyConfigsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1923,14 +2893,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_kubeconfigs" % key
+                    " to method list_remedy_configs" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_kubeconfigs`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_remedy_configs`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1958,14 +2928,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListKubeconfigs/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListRemedyConfigs/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListKubeconfigsResponse',  # noqa: E501
+            response_type='ListRemedyConfigsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1973,38 +2943,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_node_pools(self, body, **kwargs):  # noqa: E501
-        """list_node_pools  # noqa: E501
+    def list_scaling_events(self, body, **kwargs):  # noqa: E501
+        """list_scaling_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.list_node_pools(body, async_req=True)
+        >>> thread = api.list_scaling_events(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListNodePoolsRequest body: (required)
-        :return: ListNodePoolsResponse
+        :param ListScalingEventsRequest body: (required)
+        :return: ListScalingEventsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_node_pools_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_scaling_events_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_node_pools_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_scaling_events_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_node_pools_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_node_pools  # noqa: E501
+    def list_scaling_events_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_scaling_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.list_node_pools_with_http_info(body, async_req=True)
+        >>> thread = api.list_scaling_events_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListNodePoolsRequest body: (required)
-        :return: ListNodePoolsResponse
+        :param ListScalingEventsRequest body: (required)
+        :return: ListScalingEventsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2020,14 +2990,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_node_pools" % key
+                    " to method list_scaling_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 `list_node_pools`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_scaling_events`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2055,14 +3025,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListNodePools/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListScalingEvents/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListNodePoolsResponse',  # noqa: E501
+            response_type='ListScalingEventsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2070,38 +3040,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_nodes(self, body, **kwargs):  # noqa: E501
-        """list_nodes  # noqa: E501
+    def list_scaling_policies(self, body, **kwargs):  # noqa: E501
+        """list_scaling_policies  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_nodes(body, async_req=True)
+        >>> thread = api.list_scaling_policies(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListNodesRequest body: (required)
-        :return: ListNodesResponse
+        :param ListScalingPoliciesRequest body: (required)
+        :return: ListScalingPoliciesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_nodes_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_scaling_policies_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_nodes_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_scaling_policies_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_nodes_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_nodes  # noqa: E501
+    def list_scaling_policies_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_scaling_policies  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_nodes_with_http_info(body, async_req=True)
+        >>> thread = api.list_scaling_policies_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListNodesRequest body: (required)
-        :return: ListNodesResponse
+        :param ListScalingPoliciesRequest body: (required)
+        :return: ListScalingPoliciesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2117,14 +3087,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_nodes" % key
+                    " to method list_scaling_policies" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_nodes`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_scaling_policies`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2152,14 +3122,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListNodes/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListScalingPolicies/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListNodesResponse',  # noqa: E501
+            response_type='ListScalingPoliciesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2167,38 +3137,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_permissions(self, body, **kwargs):  # noqa: E501
-        """list_permissions  # noqa: E501
+    def list_supported_add_instance_types(self, body, **kwargs):  # noqa: E501
+        """list_supported_add_instance_types  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_permissions(body, async_req=True)
+        >>> thread = api.list_supported_add_instance_types(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListPermissionsRequest body: (required)
-        :return: ListPermissionsResponse
+        :param ListSupportedAddInstanceTypesRequest body: (required)
+        :return: ListSupportedAddInstanceTypesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_permissions_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_supported_add_instance_types_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_permissions_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_supported_add_instance_types_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_permissions_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_permissions  # noqa: E501
+    def list_supported_add_instance_types_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_supported_add_instance_types  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_permissions_with_http_info(body, async_req=True)
+        >>> thread = api.list_supported_add_instance_types_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListPermissionsRequest body: (required)
-        :return: ListPermissionsResponse
+        :param ListSupportedAddInstanceTypesRequest body: (required)
+        :return: ListSupportedAddInstanceTypesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2214,14 +3184,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_permissions" % key
+                    " to method list_supported_add_instance_types" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_permissions`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_supported_add_instance_types`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2249,14 +3219,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListPermissions/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListSupportedAddInstanceTypes/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListPermissionsResponse',  # noqa: E501
+            response_type='ListSupportedAddInstanceTypesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2264,38 +3234,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_scaling_events(self, body, **kwargs):  # noqa: E501
-        """list_scaling_events  # noqa: E501
+    def list_supported_addons(self, body, **kwargs):  # noqa: E501
+        """list_supported_addons  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_scaling_events(body, async_req=True)
+        >>> thread = api.list_supported_addons(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListScalingEventsRequest body: (required)
-        :return: ListScalingEventsResponse
+        :param ListSupportedAddonsRequest body: (required)
+        :return: ListSupportedAddonsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_scaling_events_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_supported_addons_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_scaling_events_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_supported_addons_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_scaling_events_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_scaling_events  # noqa: E501
+    def list_supported_addons_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_supported_addons  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_scaling_events_with_http_info(body, async_req=True)
+        >>> thread = api.list_supported_addons_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListScalingEventsRequest body: (required)
-        :return: ListScalingEventsResponse
+        :param ListSupportedAddonsRequest body: (required)
+        :return: ListSupportedAddonsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2311,14 +3281,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_scaling_events" % key
+                    " to method list_supported_addons" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_scaling_events`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_supported_addons`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2346,14 +3316,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListScalingEvents/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListSupportedAddons/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListScalingEventsResponse',  # noqa: E501
+            response_type='ListSupportedAddonsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2361,38 +3331,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_scaling_policies(self, body, **kwargs):  # noqa: E501
-        """list_scaling_policies  # noqa: E501
+    def list_supported_gpu_driver_versions(self, body, **kwargs):  # noqa: E501
+        """list_supported_gpu_driver_versions  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_scaling_policies(body, async_req=True)
+        >>> thread = api.list_supported_gpu_driver_versions(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListScalingPoliciesRequest body: (required)
-        :return: ListScalingPoliciesResponse
+        :param ListSupportedGpuDriverVersionsRequest body: (required)
+        :return: ListSupportedGpuDriverVersionsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_scaling_policies_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_supported_gpu_driver_versions_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_scaling_policies_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_supported_gpu_driver_versions_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_scaling_policies_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_scaling_policies  # noqa: E501
+    def list_supported_gpu_driver_versions_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_supported_gpu_driver_versions  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_scaling_policies_with_http_info(body, async_req=True)
+        >>> thread = api.list_supported_gpu_driver_versions_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListScalingPoliciesRequest body: (required)
-        :return: ListScalingPoliciesResponse
+        :param ListSupportedGpuDriverVersionsRequest body: (required)
+        :return: ListSupportedGpuDriverVersionsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2408,14 +3378,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_scaling_policies" % key
+                    " to method list_supported_gpu_driver_versions" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_scaling_policies`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_supported_gpu_driver_versions`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2443,14 +3413,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListScalingPolicies/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListSupportedGpuDriverVersions/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListScalingPoliciesResponse',  # noqa: E501
+            response_type='ListSupportedGpuDriverVersionsResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2458,38 +3428,38 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_supported_addons(self, body, **kwargs):  # noqa: E501
-        """list_supported_addons  # noqa: E501
+    def list_supported_images(self, body, **kwargs):  # noqa: E501
+        """list_supported_images  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_supported_addons(body, async_req=True)
+        >>> thread = api.list_supported_images(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListSupportedAddonsRequest body: (required)
-        :return: ListSupportedAddonsResponse
+        :param ListSupportedImagesRequest body: (required)
+        :return: ListSupportedImagesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_supported_addons_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_supported_images_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_supported_addons_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_supported_images_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_supported_addons_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_supported_addons  # noqa: E501
+    def list_supported_images_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_supported_images  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_supported_addons_with_http_info(body, async_req=True)
+        >>> thread = api.list_supported_images_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListSupportedAddonsRequest body: (required)
-        :return: ListSupportedAddonsResponse
+        :param ListSupportedImagesRequest body: (required)
+        :return: ListSupportedImagesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2505,14 +3475,14 @@ class VKEApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_supported_addons" % key
+                    " to method list_supported_images" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `list_supported_addons`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_supported_images`")  # noqa: E501
 
         collection_formats = {}
 
@@ -2540,14 +3510,14 @@ class VKEApi(object):
         auth_settings = ['byteplusSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListSupportedAddons/2022-05-12/vke/post/application_json/', 'POST',
+            '/ListSupportedImages/2022-05-12/vke/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListSupportedAddonsResponse',  # noqa: E501
+            response_type='ListSupportedImagesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3040,6 +4010,103 @@ class VKEApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def unbinding_remedy_config(self, body, **kwargs):  # noqa: E501
+        """unbinding_remedy_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.unbinding_remedy_config(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UnbindingRemedyConfigRequest body: (required)
+        :return: UnbindingRemedyConfigResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.unbinding_remedy_config_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.unbinding_remedy_config_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def unbinding_remedy_config_with_http_info(self, body, **kwargs):  # noqa: E501
+        """unbinding_remedy_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.unbinding_remedy_config_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UnbindingRemedyConfigRequest body: (required)
+        :return: UnbindingRemedyConfigResponse
+                 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 unbinding_remedy_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 `unbinding_remedy_config`")  # 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 = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/UnbindingRemedyConfig/2022-05-12/vke/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UnbindingRemedyConfigResponse',  # 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 untag_resources(self, body, **kwargs):  # noqa: E501
         """untag_resources  # noqa: E501