volcengine-python-sdk 4.0.23__py2.py3-none-any.whl → 4.0.24__py2.py3-none-any.whl

volcenginesdkvmp/api/vmp_api.py

@@ -324,6 +324,103 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def create_integration_task(self, body, **kwargs):  # noqa: E501
+        """create_integration_task  # 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_integration_task(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateIntegrationTaskRequest body: (required)
+        :return: CreateIntegrationTaskResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.create_integration_task_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.create_integration_task_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def create_integration_task_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_integration_task  # 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_integration_task_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateIntegrationTaskRequest body: (required)
+        :return: CreateIntegrationTaskResponse
+                 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_integration_task" % 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_integration_task`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/CreateIntegrationTask/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='CreateIntegrationTaskResponse',  # 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_notify_group_policy(self, body, **kwargs):  # noqa: E501
         """create_notify_group_policy  # noqa: E501
 
@@ -712,6 +809,103 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def create_silence_policy(self, body, **kwargs):  # noqa: E501
+        """create_silence_policy  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.create_silence_policy(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateSilencePolicyRequest body: (required)
+        :return: CreateSilencePolicyResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.create_silence_policy_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.create_silence_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def create_silence_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """create_silence_policy  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.create_silence_policy_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param CreateSilencePolicyRequest body: (required)
+        :return: CreateSilencePolicyResponse
+                 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_silence_policy" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `create_silence_policy`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/CreateSilencePolicy/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='CreateSilencePolicyResponse',  # 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_workspace(self, body, **kwargs):  # noqa: E501
         """create_workspace  # noqa: E501
 
@@ -1100,6 +1294,103 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def delete_integration_task(self, body, **kwargs):  # noqa: E501
+        """delete_integration_task  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_integration_task(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteIntegrationTaskRequest body: (required)
+        :return: DeleteIntegrationTaskResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_integration_task_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_integration_task_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_integration_task_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_integration_task  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_integration_task_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteIntegrationTaskRequest body: (required)
+        :return: DeleteIntegrationTaskResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method delete_integration_task" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_integration_task`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteIntegrationTask/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteIntegrationTaskResponse',  # 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_notify_group_policy(self, body, **kwargs):  # noqa: E501
         """delete_notify_group_policy  # noqa: E501
 
@@ -1383,7 +1674,492 @@ class VMPApi(object):
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteNotifyTemplateResponse',  # noqa: E501
+            response_type='DeleteNotifyTemplateResponse',  # 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_rule_file(self, body, **kwargs):  # noqa: E501
+        """delete_rule_file  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_rule_file(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteRuleFileRequest body: (required)
+        :return: DeleteRuleFileResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_rule_file_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_rule_file_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_rule_file_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_rule_file  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_rule_file_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteRuleFileRequest body: (required)
+        :return: DeleteRuleFileResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method delete_rule_file" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_rule_file`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteRuleFile/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteRuleFileResponse',  # 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_silence_policies(self, body, **kwargs):  # noqa: E501
+        """delete_silence_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.delete_silence_policies(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteSilencePoliciesRequest body: (required)
+        :return: DeleteSilencePoliciesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_silence_policies_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_silence_policies_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_silence_policies_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_silence_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.delete_silence_policies_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteSilencePoliciesRequest body: (required)
+        :return: DeleteSilencePoliciesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method delete_silence_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 `delete_silence_policies`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteSilencePolicies/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteSilencePoliciesResponse',  # 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_workspace(self, body, **kwargs):  # noqa: E501
+        """delete_workspace  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_workspace(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteWorkspaceRequest body: (required)
+        :return: DeleteWorkspaceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.delete_workspace_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.delete_workspace_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def delete_workspace_with_http_info(self, body, **kwargs):  # noqa: E501
+        """delete_workspace  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.delete_workspace_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DeleteWorkspaceRequest body: (required)
+        :return: DeleteWorkspaceResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method delete_workspace" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `delete_workspace`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DeleteWorkspace/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DeleteWorkspaceResponse',  # 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 disable_alerting_rules(self, body, **kwargs):  # noqa: E501
+        """disable_alerting_rules  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.disable_alerting_rules(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DisableAlertingRulesRequest body: (required)
+        :return: DisableAlertingRulesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.disable_alerting_rules_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.disable_alerting_rules_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def disable_alerting_rules_with_http_info(self, body, **kwargs):  # noqa: E501
+        """disable_alerting_rules  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.disable_alerting_rules_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DisableAlertingRulesRequest body: (required)
+        :return: DisableAlertingRulesResponse
+                 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 disable_alerting_rules" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `disable_alerting_rules`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DisableAlertingRules/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DisableAlertingRulesResponse',  # 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 disable_integration_tasks(self, body, **kwargs):  # noqa: E501
+        """disable_integration_tasks  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.disable_integration_tasks(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DisableIntegrationTasksRequest body: (required)
+        :return: DisableIntegrationTasksResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.disable_integration_tasks_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.disable_integration_tasks_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def disable_integration_tasks_with_http_info(self, body, **kwargs):  # noqa: E501
+        """disable_integration_tasks  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.disable_integration_tasks_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param DisableIntegrationTasksRequest body: (required)
+        :return: DisableIntegrationTasksResponse
+                 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 disable_integration_tasks" % 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 `disable_integration_tasks`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/DisableIntegrationTasks/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DisableIntegrationTasksResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1391,38 +2167,38 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_rule_file(self, body, **kwargs):  # noqa: E501
-        """delete_rule_file  # noqa: E501
+    def disable_silence_policies(self, body, **kwargs):  # noqa: E501
+        """disable_silence_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.delete_rule_file(body, async_req=True)
+        >>> thread = api.disable_silence_policies(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteRuleFileRequest body: (required)
-        :return: DeleteRuleFileResponse
+        :param DisableSilencePoliciesRequest body: (required)
+        :return: DisableSilencePoliciesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_rule_file_with_http_info(body, **kwargs)  # noqa: E501
+            return self.disable_silence_policies_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_rule_file_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.disable_silence_policies_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_rule_file_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_rule_file  # noqa: E501
+    def disable_silence_policies_with_http_info(self, body, **kwargs):  # noqa: E501
+        """disable_silence_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.delete_rule_file_with_http_info(body, async_req=True)
+        >>> thread = api.disable_silence_policies_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteRuleFileRequest body: (required)
-        :return: DeleteRuleFileResponse
+        :param DisableSilencePoliciesRequest body: (required)
+        :return: DisableSilencePoliciesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1438,14 +2214,14 @@ class VMPApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_rule_file" % key
+                    " to method disable_silence_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 `delete_rule_file`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `disable_silence_policies`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1473,14 +2249,14 @@ class VMPApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteRuleFile/2021-03-03/vmp/post/application_json/', 'POST',
+            '/DisableSilencePolicies/2021-03-03/vmp/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteRuleFileResponse',  # noqa: E501
+            response_type='DisableSilencePoliciesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1488,38 +2264,38 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_workspace(self, body, **kwargs):  # noqa: E501
-        """delete_workspace  # noqa: E501
+    def enable_alerting_rules(self, body, **kwargs):  # noqa: E501
+        """enable_alerting_rules  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_workspace(body, async_req=True)
+        >>> thread = api.enable_alerting_rules(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteWorkspaceRequest body: (required)
-        :return: DeleteWorkspaceResponse
+        :param EnableAlertingRulesRequest body: (required)
+        :return: EnableAlertingRulesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.delete_workspace_with_http_info(body, **kwargs)  # noqa: E501
+            return self.enable_alerting_rules_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.delete_workspace_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.enable_alerting_rules_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def delete_workspace_with_http_info(self, body, **kwargs):  # noqa: E501
-        """delete_workspace  # noqa: E501
+    def enable_alerting_rules_with_http_info(self, body, **kwargs):  # noqa: E501
+        """enable_alerting_rules  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_workspace_with_http_info(body, async_req=True)
+        >>> thread = api.enable_alerting_rules_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DeleteWorkspaceRequest body: (required)
-        :return: DeleteWorkspaceResponse
+        :param EnableAlertingRulesRequest body: (required)
+        :return: EnableAlertingRulesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1535,14 +2311,14 @@ class VMPApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_workspace" % key
+                    " to method enable_alerting_rules" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if self.api_client.client_side_validation and ('body' not in params or
                                                        params['body'] is None):  # noqa: E501
-            raise ValueError("Missing the required parameter `body` when calling `delete_workspace`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `enable_alerting_rules`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1570,14 +2346,14 @@ class VMPApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DeleteWorkspace/2021-03-03/vmp/post/application_json/', 'POST',
+            '/EnableAlertingRules/2021-03-03/vmp/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DeleteWorkspaceResponse',  # noqa: E501
+            response_type='EnableAlertingRulesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1585,38 +2361,38 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def disable_alerting_rules(self, body, **kwargs):  # noqa: E501
-        """disable_alerting_rules  # noqa: E501
+    def enable_integration_tasks(self, body, **kwargs):  # noqa: E501
+        """enable_integration_tasks  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.disable_alerting_rules(body, async_req=True)
+        >>> thread = api.enable_integration_tasks(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DisableAlertingRulesRequest body: (required)
-        :return: DisableAlertingRulesResponse
+        :param EnableIntegrationTasksRequest body: (required)
+        :return: EnableIntegrationTasksResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.disable_alerting_rules_with_http_info(body, **kwargs)  # noqa: E501
+            return self.enable_integration_tasks_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.disable_alerting_rules_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.enable_integration_tasks_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def disable_alerting_rules_with_http_info(self, body, **kwargs):  # noqa: E501
-        """disable_alerting_rules  # noqa: E501
+    def enable_integration_tasks_with_http_info(self, body, **kwargs):  # noqa: E501
+        """enable_integration_tasks  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.disable_alerting_rules_with_http_info(body, async_req=True)
+        >>> thread = api.enable_integration_tasks_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param DisableAlertingRulesRequest body: (required)
-        :return: DisableAlertingRulesResponse
+        :param EnableIntegrationTasksRequest body: (required)
+        :return: EnableIntegrationTasksResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1632,14 +2408,14 @@ class VMPApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method disable_alerting_rules" % key
+                    " to method enable_integration_tasks" % 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 `disable_alerting_rules`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `enable_integration_tasks`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1667,14 +2443,14 @@ class VMPApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/DisableAlertingRules/2021-03-03/vmp/post/application_json/', 'POST',
+            '/EnableIntegrationTasks/2021-03-03/vmp/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DisableAlertingRulesResponse',  # noqa: E501
+            response_type='EnableIntegrationTasksResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -1682,38 +2458,38 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def enable_alerting_rules(self, body, **kwargs):  # noqa: E501
-        """enable_alerting_rules  # noqa: E501
+    def enable_silence_policies(self, body, **kwargs):  # noqa: E501
+        """enable_silence_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.enable_alerting_rules(body, async_req=True)
+        >>> thread = api.enable_silence_policies(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param EnableAlertingRulesRequest body: (required)
-        :return: EnableAlertingRulesResponse
+        :param EnableSilencePoliciesRequest body: (required)
+        :return: EnableSilencePoliciesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.enable_alerting_rules_with_http_info(body, **kwargs)  # noqa: E501
+            return self.enable_silence_policies_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.enable_alerting_rules_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.enable_silence_policies_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def enable_alerting_rules_with_http_info(self, body, **kwargs):  # noqa: E501
-        """enable_alerting_rules  # noqa: E501
+    def enable_silence_policies_with_http_info(self, body, **kwargs):  # noqa: E501
+        """enable_silence_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.enable_alerting_rules_with_http_info(body, async_req=True)
+        >>> thread = api.enable_silence_policies_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param EnableAlertingRulesRequest body: (required)
-        :return: EnableAlertingRulesResponse
+        :param EnableSilencePoliciesRequest body: (required)
+        :return: EnableSilencePoliciesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -1729,14 +2505,14 @@ class VMPApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method enable_alerting_rules" % key
+                    " to method enable_silence_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 `enable_alerting_rules`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `enable_silence_policies`")  # noqa: E501
 
         collection_formats = {}
 
@@ -1764,14 +2540,14 @@ class VMPApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/EnableAlertingRules/2021-03-03/vmp/post/application_json/', 'POST',
+            '/EnableSilencePolicies/2021-03-03/vmp/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='EnableAlertingRulesResponse',  # noqa: E501
+            response_type='EnableSilencePoliciesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -2167,6 +2943,103 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def get_integration_task(self, body, **kwargs):  # noqa: E501
+        """get_integration_task  # 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_integration_task(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetIntegrationTaskRequest body: (required)
+        :return: GetIntegrationTaskResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.get_integration_task_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.get_integration_task_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def get_integration_task_with_http_info(self, body, **kwargs):  # noqa: E501
+        """get_integration_task  # 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_integration_task_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param GetIntegrationTaskRequest body: (required)
+        :return: GetIntegrationTaskResponse
+                 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_integration_task" % 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_integration_task`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/GetIntegrationTask/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GetIntegrationTaskResponse',  # 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_notify_group_policy(self, body, **kwargs):  # noqa: E501
         """get_notify_group_policy  # noqa: E501
 
@@ -2952,29 +3825,126 @@ class VMPApi(object):
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListContactsRequest body: (required)
-        :return: ListContactsResponse
+        :param ListContactsRequest body: (required)
+        :return: ListContactsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_contacts_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_contacts_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_contacts_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_contacts  # 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_contacts_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListContactsRequest body: (required)
+        :return: ListContactsResponse
+                 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_contacts" % 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_contacts`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListContacts/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListContactsResponse',  # 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_integration_tasks(self, body, **kwargs):  # noqa: E501
+        """list_integration_tasks  # 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_integration_tasks(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListIntegrationTasksRequest body: (required)
+        :return: ListIntegrationTasksResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.list_contacts_with_http_info(body, **kwargs)  # noqa: E501
+            return self.list_integration_tasks_with_http_info(body, **kwargs)  # noqa: E501
         else:
-            (data) = self.list_contacts_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.list_integration_tasks_with_http_info(body, **kwargs)  # noqa: E501
             return data
 
-    def list_contacts_with_http_info(self, body, **kwargs):  # noqa: E501
-        """list_contacts  # noqa: E501
+    def list_integration_tasks_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_integration_tasks  # 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_contacts_with_http_info(body, async_req=True)
+        >>> thread = api.list_integration_tasks_with_http_info(body, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param ListContactsRequest body: (required)
-        :return: ListContactsResponse
+        :param ListIntegrationTasksRequest body: (required)
+        :return: ListIntegrationTasksResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -2990,14 +3960,14 @@ class VMPApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_contacts" % key
+                    " to method list_integration_tasks" % 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_contacts`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `list_integration_tasks`")  # noqa: E501
 
         collection_formats = {}
 
@@ -3025,14 +3995,14 @@ class VMPApi(object):
         auth_settings = ['volcengineSign']  # noqa: E501
 
         return self.api_client.call_api(
-            '/ListContacts/2021-03-03/vmp/post/application_json/', 'POST',
+            '/ListIntegrationTasks/2021-03-03/vmp/post/application_json/', 'POST',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ListContactsResponse',  # noqa: E501
+            response_type='ListIntegrationTasksResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -3525,6 +4495,103 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def list_silence_policies(self, body, **kwargs):  # noqa: E501
+        """list_silence_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_silence_policies(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListSilencePoliciesRequest body: (required)
+        :return: ListSilencePoliciesResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.list_silence_policies_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.list_silence_policies_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def list_silence_policies_with_http_info(self, body, **kwargs):  # noqa: E501
+        """list_silence_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_silence_policies_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ListSilencePoliciesRequest body: (required)
+        :return: ListSilencePoliciesResponse
+                 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_silence_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_silence_policies`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/ListSilencePolicies/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ListSilencePoliciesResponse',  # 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_tags_for_resources(self, body, **kwargs):  # noqa: E501
         """list_tags_for_resources  # noqa: E501
 
@@ -4883,6 +5950,103 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def update_integration_task(self, body, **kwargs):  # noqa: E501
+        """update_integration_task  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_integration_task(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateIntegrationTaskRequest body: (required)
+        :return: UpdateIntegrationTaskResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.update_integration_task_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.update_integration_task_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def update_integration_task_with_http_info(self, body, **kwargs):  # noqa: E501
+        """update_integration_task  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_integration_task_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateIntegrationTaskRequest body: (required)
+        :return: UpdateIntegrationTaskResponse
+                 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 update_integration_task" % 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 `update_integration_task`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/UpdateIntegrationTask/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UpdateIntegrationTaskResponse',  # 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 update_notify_group_policy(self, body, **kwargs):  # noqa: E501
         """update_notify_group_policy  # noqa: E501
 
@@ -5271,6 +6435,103 @@ class VMPApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def update_silence_policy(self, body, **kwargs):  # noqa: E501
+        """update_silence_policy  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_silence_policy(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateSilencePolicyRequest body: (required)
+        :return: UpdateSilencePolicyResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.update_silence_policy_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.update_silence_policy_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def update_silence_policy_with_http_info(self, body, **kwargs):  # noqa: E501
+        """update_silence_policy  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_silence_policy_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateSilencePolicyRequest body: (required)
+        :return: UpdateSilencePolicyResponse
+                 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 update_silence_policy" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `update_silence_policy`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['volcengineSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/UpdateSilencePolicy/2021-03-03/vmp/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UpdateSilencePolicyResponse',  # 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 update_workspace(self, body, **kwargs):  # noqa: E501
         """update_workspace  # noqa: E501