# coding: utf-8

"""
    Paragon Insights APIs

    API interface for PI application  # noqa: E501

    OpenAPI spec version: 4.0.0
    Contact: healthbot-feedback@juniper.net
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from jnpr.healthbot.swagger.api_client import ApiClient


class DefaultApi(object):
    """NOTE: This class is auto generated by the swagger code generator program.

    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def backup_grafana(self, **kwargs):  # noqa: E501
        """Take backup of Grafana configuration  # noqa: E501

        Take backup of Grafana configuration  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.backup_grafana(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.backup_grafana_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.backup_grafana_with_http_info(**kwargs)  # noqa: E501
            return data

    def backup_grafana_with_http_info(self, **kwargs):  # noqa: E501
        """Take backup of Grafana configuration  # noqa: E501

        Take backup of Grafana configuration  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.backup_grafana_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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 backup_grafana" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/grafana/backup/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='file',  # 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 backup_helper_files(self, **kwargs):  # noqa: E501
        """Download the tar file containing all helper files.  # noqa: E501

        Download helper files tar file, which will include the config and input directory.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.backup_helper_files(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.backup_helper_files_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.backup_helper_files_with_http_info(**kwargs)  # noqa: E501
            return data

    def backup_helper_files_with_http_info(self, **kwargs):  # noqa: E501
        """Download the tar file containing all helper files.  # noqa: E501

        Download helper files tar file, which will include the config and input directory.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.backup_helper_files_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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 backup_helper_files" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/helper-files/backup/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='file',  # 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_dynamic_tagging_by_key(self, key_name, dynamic_tagging_obj, **kwargs):  # noqa: E501
        """Creates Dynamic-tagging key-value  # noqa: E501

        Creates a key in Dynamic-tagging  # 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_dynamic_tagging_by_key(key_name, dynamic_tagging_obj, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str key_name: Dynamic-tagging Key (required)
        :param DynamicTaggingSchemaObject dynamic_tagging_obj: Dynamic-tagging object containing key-value pair (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_dynamic_tagging_by_key_with_http_info(key_name, dynamic_tagging_obj, **kwargs)  # noqa: E501
        else:
            (data) = self.create_dynamic_tagging_by_key_with_http_info(key_name, dynamic_tagging_obj, **kwargs)  # noqa: E501
            return data

    def create_dynamic_tagging_by_key_with_http_info(self, key_name, dynamic_tagging_obj, **kwargs):  # noqa: E501
        """Creates Dynamic-tagging key-value  # noqa: E501

        Creates a key in Dynamic-tagging  # 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_dynamic_tagging_by_key_with_http_info(key_name, dynamic_tagging_obj, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str key_name: Dynamic-tagging Key (required)
        :param DynamicTaggingSchemaObject dynamic_tagging_obj: Dynamic-tagging object containing key-value pair (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['key_name', 'dynamic_tagging_obj', 'x_iam_token']  # 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_dynamic_tagging_by_key" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'key_name' is set
        if ('key_name' not in params or
                params['key_name'] is None):
            raise ValueError("Missing the required parameter `key_name` when calling `create_dynamic_tagging_by_key`")  # noqa: E501
        # verify the required parameter 'dynamic_tagging_obj' is set
        if ('dynamic_tagging_obj' not in params or
                params['dynamic_tagging_obj'] is None):
            raise ValueError("Missing the required parameter `dynamic_tagging_obj` when calling `create_dynamic_tagging_by_key`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'key_name' in params:
            query_params.append(('key_name', params['key_name']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'dynamic_tagging_obj' in params:
            body_params = params['dynamic_tagging_obj']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/dynamic-tagging/key/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_files_certificates_by_file_name(self, up_file, file_name, **kwargs):  # noqa: E501
        """Upload a certificate file.  # noqa: E501

        Upload the specified certificate-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.create_files_certificates_by_file_name(up_file, file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file up_file: File content (required)
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str password: password
        :param str certificate_type: Certificate type
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_files_certificates_by_file_name_with_http_info(up_file, file_name, **kwargs)  # noqa: E501
        else:
            (data) = self.create_files_certificates_by_file_name_with_http_info(up_file, file_name, **kwargs)  # noqa: E501
            return data

    def create_files_certificates_by_file_name_with_http_info(self, up_file, file_name, **kwargs):  # noqa: E501
        """Upload a certificate file.  # noqa: E501

        Upload the specified certificate-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.create_files_certificates_by_file_name_with_http_info(up_file, file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file up_file: File content (required)
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str password: password
        :param str certificate_type: Certificate type
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['up_file', 'file_name', 'x_iam_token', 'password', 'certificate_type']  # 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_files_certificates_by_file_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'up_file' is set
        if ('up_file' not in params or
                params['up_file'] is None):
            raise ValueError("Missing the required parameter `up_file` when calling `create_files_certificates_by_file_name`")  # noqa: E501
        # verify the required parameter 'file_name' is set
        if ('file_name' not in params or
                params['file_name'] is None):
            raise ValueError("Missing the required parameter `file_name` when calling `create_files_certificates_by_file_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'file_name' in params:
            path_params['file_name'] = params['file_name']  # noqa: E501

        query_params = []
        if 'password' in params:
            query_params.append(('password', params['password']))  # noqa: E501
        if 'certificate_type' in params:
            query_params.append(('certificate_type', params['certificate_type']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}
        if 'up_file' in params:
            local_var_files['up_file'] = params['up_file']  # noqa: E501

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/certificates/{file_name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_files_helper_files_by_file_name(self, up_file, file_name, **kwargs):  # noqa: E501
        """Upload a helper-file.  # noqa: E501

        Upload the specified helper-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.create_files_helper_files_by_file_name(up_file, file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file up_file: File content (required)
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_files_helper_files_by_file_name_with_http_info(up_file, file_name, **kwargs)  # noqa: E501
        else:
            (data) = self.create_files_helper_files_by_file_name_with_http_info(up_file, file_name, **kwargs)  # noqa: E501
            return data

    def create_files_helper_files_by_file_name_with_http_info(self, up_file, file_name, **kwargs):  # noqa: E501
        """Upload a helper-file.  # noqa: E501

        Upload the specified helper-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.create_files_helper_files_by_file_name_with_http_info(up_file, file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file up_file: File content (required)
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['up_file', 'file_name', 'x_iam_token']  # 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_files_helper_files_by_file_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'up_file' is set
        if ('up_file' not in params or
                params['up_file'] is None):
            raise ValueError("Missing the required parameter `up_file` when calling `create_files_helper_files_by_file_name`")  # noqa: E501
        # verify the required parameter 'file_name' is set
        if ('file_name' not in params or
                params['file_name'] is None):
            raise ValueError("Missing the required parameter `file_name` when calling `create_files_helper_files_by_file_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'file_name' in params:
            path_params['file_name'] = params['file_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}
        if 'up_file' in params:
            local_var_files['up_file'] = params['up_file']  # noqa: E501

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/helper-files/{file_name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_deployment_deployment_by_id(self, deployment, **kwargs):  # noqa: E501
        """Create deployment by ID  # noqa: E501

        Create operation of resource: deployment  # 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_healthbot_deployment_deployment_by_id(deployment, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeploymentSchema deployment: deployment body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_deployment_deployment_by_id_with_http_info(deployment, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_deployment_deployment_by_id_with_http_info(deployment, **kwargs)  # noqa: E501
            return data

    def create_healthbot_deployment_deployment_by_id_with_http_info(self, deployment, **kwargs):  # noqa: E501
        """Create deployment by ID  # noqa: E501

        Create operation of resource: deployment  # 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_healthbot_deployment_deployment_by_id_with_http_info(deployment, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeploymentSchema deployment: deployment body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment', 'x_iam_token']  # 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_healthbot_deployment_deployment_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment' is set
        if ('deployment' not in params or
                params['deployment'] is None):
            raise ValueError("Missing the required parameter `deployment` when calling `create_healthbot_deployment_deployment_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'deployment' in params:
            body_params = params['deployment']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/deployment/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_dynamic_tagging(self, dynamic_tagging, **kwargs):  # noqa: E501
        """Create dynamic-tagging by ID  # noqa: E501

        Create operation of resource: dynamic-tagging  # 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_healthbot_dynamic_tagging(dynamic_tagging, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DynamicTaggingsSchemaObject dynamic_tagging: dynamic_taggingbody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_dynamic_tagging_with_http_info(dynamic_tagging, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_dynamic_tagging_with_http_info(dynamic_tagging, **kwargs)  # noqa: E501
            return data

    def create_healthbot_dynamic_tagging_with_http_info(self, dynamic_tagging, **kwargs):  # noqa: E501
        """Create dynamic-tagging by ID  # noqa: E501

        Create operation of resource: dynamic-tagging  # 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_healthbot_dynamic_tagging_with_http_info(dynamic_tagging, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DynamicTaggingsSchemaObject dynamic_tagging: dynamic_taggingbody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['dynamic_tagging', 'x_iam_token']  # 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_healthbot_dynamic_tagging" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'dynamic_tagging' is set
        if ('dynamic_tagging' not in params or
                params['dynamic_tagging'] is None):
            raise ValueError("Missing the required parameter `dynamic_tagging` when calling `create_healthbot_dynamic_tagging`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'dynamic_tagging' in params:
            body_params = params['dynamic_tagging']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/dynamic-tagging/keys/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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_healthbot_ingest_byoi_custom_plugin_by_id(self, name, custom_plugin, **kwargs):  # noqa: E501
        """Create custom-plugin by ID  # noqa: E501

        Create operation of resource: custom-plugin  # 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_healthbot_ingest_byoi_custom_plugin_by_id(name, custom_plugin, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param CustomPluginSchema custom_plugin: custom_pluginbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(self, name, custom_plugin, **kwargs):  # noqa: E501
        """Create custom-plugin by ID  # noqa: E501

        Create operation of resource: custom-plugin  # 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_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param CustomPluginSchema custom_plugin: custom_pluginbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'custom_plugin', 'x_iam_token']  # 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_healthbot_ingest_byoi_custom_plugin_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_byoi_custom_plugin_by_id`")  # noqa: E501
        # verify the required parameter 'custom_plugin' is set
        if ('custom_plugin' not in params or
                params['custom_plugin'] is None):
            raise ValueError("Missing the required parameter `custom_plugin` when calling `create_healthbot_ingest_byoi_custom_plugin_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'custom_plugin' in params:
            body_params = params['custom_plugin']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/custom-plugin/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id(self, name, tlive_kafka, **kwargs):  # noqa: E501
        """Create tlive-kafka-oc by ID  # noqa: E501

        Add/Merge a tlive-kafka-oc configuration.  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id(name, tlive_kafka, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param TliveKafkaOcSchema tlive_kafka: tlive_kafkabody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(self, name, tlive_kafka, **kwargs):  # noqa: E501
        """Create tlive-kafka-oc by ID  # noqa: E501

        Add/Merge a tlive-kafka-oc configuration.  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param TliveKafkaOcSchema tlive_kafka: tlive_kafkabody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'tlive_kafka', 'x_iam_token']  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501
        # verify the required parameter 'tlive_kafka' is set
        if ('tlive_kafka' not in params or
                params['tlive_kafka'] is None):
            raise ValueError("Missing the required parameter `tlive_kafka` when calling `create_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tlive_kafka' in params:
            body_params = params['tlive_kafka']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/default-plugin/tlive-kafka-oc/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_byoi_ingest_mapping_by_id(self, name, ingest_mapping, **kwargs):  # noqa: E501
        """Create ingest-mapping by ID  # noqa: E501

        Create ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_healthbot_ingest_byoi_ingest_mapping_by_id(name, ingest_mapping, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param IngestMappingSchema ingest_mapping: ingest_mappingbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(self, name, ingest_mapping, **kwargs):  # noqa: E501
        """Create ingest-mapping by ID  # noqa: E501

        Create ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param IngestMappingSchema ingest_mapping: ingest_mappingbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'ingest_mapping', 'x_iam_token']  # 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_healthbot_ingest_byoi_ingest_mapping_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_byoi_ingest_mapping_by_id`")  # noqa: E501
        # verify the required parameter 'ingest_mapping' is set
        if ('ingest_mapping' not in params or
                params['ingest_mapping'] is None):
            raise ValueError("Missing the required parameter `ingest_mapping` when calling `create_healthbot_ingest_byoi_ingest_mapping_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ingest_mapping' in params:
            body_params = params['ingest_mapping']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/ingest-mapping/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_frequency_profile_by_id(self, name, frequency_profile, **kwargs):  # noqa: E501
        """Create frequency-profile by ID  # noqa: E501

        Create operation of resource: frequency-profile  # 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_healthbot_ingest_frequency_profile_by_id(name, frequency_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param FrequencyProfileSchema frequency_profile: frequency_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_frequency_profile_by_id_with_http_info(name, frequency_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_frequency_profile_by_id_with_http_info(name, frequency_profile, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_frequency_profile_by_id_with_http_info(self, name, frequency_profile, **kwargs):  # noqa: E501
        """Create frequency-profile by ID  # noqa: E501

        Create operation of resource: frequency-profile  # 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_healthbot_ingest_frequency_profile_by_id_with_http_info(name, frequency_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param FrequencyProfileSchema frequency_profile: frequency_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'frequency_profile', 'x_iam_token']  # 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_healthbot_ingest_frequency_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_frequency_profile_by_id`")  # noqa: E501
        # verify the required parameter 'frequency_profile' is set
        if ('frequency_profile' not in params or
                params['frequency_profile'] is None):
            raise ValueError("Missing the required parameter `frequency_profile` when calling `create_healthbot_ingest_frequency_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'frequency_profile' in params:
            body_params = params['frequency_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/frequency-profile/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_outbound_ssh(self, outbound_ssh, **kwargs):  # noqa: E501
        """Create outbound-ssh by ID  # noqa: E501

        Create operation of resource: outbound-ssh  # 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_healthbot_ingest_outbound_ssh(outbound_ssh, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param OutboundSshSchema outbound_ssh: outbound_ssh body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_outbound_ssh_with_http_info(outbound_ssh, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_outbound_ssh_with_http_info(outbound_ssh, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_outbound_ssh_with_http_info(self, outbound_ssh, **kwargs):  # noqa: E501
        """Create outbound-ssh by ID  # noqa: E501

        Create operation of resource: outbound-ssh  # 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_healthbot_ingest_outbound_ssh_with_http_info(outbound_ssh, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param OutboundSshSchema outbound_ssh: outbound_ssh body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['outbound_ssh', 'x_iam_token']  # 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_healthbot_ingest_outbound_ssh" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'outbound_ssh' is set
        if ('outbound_ssh' not in params or
                params['outbound_ssh'] is None):
            raise ValueError("Missing the required parameter `outbound_ssh` when calling `create_healthbot_ingest_outbound_ssh`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'outbound_ssh' in params:
            body_params = params['outbound_ssh']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/outbound-ssh/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id(self, name, custom_plugin, **kwargs):  # noqa: E501
        """Create custom-plugin by ID  # noqa: E501

        Create operation of resource: custom-plugin  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id(name, custom_plugin, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param CustomPluginSchema custom_plugin: custom_pluginbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(self, name, custom_plugin, **kwargs):  # noqa: E501
        """Create custom-plugin by ID  # noqa: E501

        Create operation of resource: custom-plugin  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param CustomPluginSchema custom_plugin: custom_pluginbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'custom_plugin', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_settings_byoi_custom_plugin_by_id`")  # noqa: E501
        # verify the required parameter 'custom_plugin' is set
        if ('custom_plugin' not in params or
                params['custom_plugin'] is None):
            raise ValueError("Missing the required parameter `custom_plugin` when calling `create_healthbot_ingest_settings_byoi_custom_plugin_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'custom_plugin' in params:
            body_params = params['custom_plugin']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/custom-plugin/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id(self, name, tlive_kafka, **kwargs):  # noqa: E501
        """Create tlive-kafka-oc by ID  # noqa: E501

        Add/Merge a tlive-kafka-oc configuration.  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id(name, tlive_kafka, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param TliveKafkaOcSchema tlive_kafka: tlive_kafkabody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(self, name, tlive_kafka, **kwargs):  # noqa: E501
        """Create tlive-kafka-oc by ID  # noqa: E501

        Add/Merge a tlive-kafka-oc configuration.  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param TliveKafkaOcSchema tlive_kafka: tlive_kafkabody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'tlive_kafka', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501
        # verify the required parameter 'tlive_kafka' is set
        if ('tlive_kafka' not in params or
                params['tlive_kafka'] is None):
            raise ValueError("Missing the required parameter `tlive_kafka` when calling `create_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tlive_kafka' in params:
            body_params = params['tlive_kafka']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/default-plugin/tlive-kafka-oc/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_ingest_mapping_by_id(self, name, ingest_mapping, **kwargs):  # noqa: E501
        """Create ingest-mapping by ID  # noqa: E501

        Create ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_healthbot_ingest_settings_byoi_ingest_mapping_by_id(name, ingest_mapping, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param IngestMappingSchema ingest_mapping: ingest_mappingbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(self, name, ingest_mapping, **kwargs):  # noqa: E501
        """Create ingest-mapping by ID  # noqa: E501

        Create ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param IngestMappingSchema ingest_mapping: ingest_mappingbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'ingest_mapping', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_ingest_mapping_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_settings_byoi_ingest_mapping_by_id`")  # noqa: E501
        # verify the required parameter 'ingest_mapping' is set
        if ('ingest_mapping' not in params or
                params['ingest_mapping'] is None):
            raise ValueError("Missing the required parameter `ingest_mapping` when calling `create_healthbot_ingest_settings_byoi_ingest_mapping_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ingest_mapping' in params:
            body_params = params['ingest_mapping']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/ingest-mapping/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_frequency_profile_by_id(self, name, frequency_profile, **kwargs):  # noqa: E501
        """Create frequency-profile by ID  # noqa: E501

        Create operation of resource: frequency-profile  # 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_healthbot_ingest_settings_frequency_profile_by_id(name, frequency_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param FrequencyProfileSchema frequency_profile: frequency_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, frequency_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, frequency_profile, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(self, name, frequency_profile, **kwargs):  # noqa: E501
        """Create frequency-profile by ID  # noqa: E501

        Create operation of resource: frequency-profile  # 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_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, frequency_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param FrequencyProfileSchema frequency_profile: frequency_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'frequency_profile', 'x_iam_token']  # 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_healthbot_ingest_settings_frequency_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_settings_frequency_profile_by_id`")  # noqa: E501
        # verify the required parameter 'frequency_profile' is set
        if ('frequency_profile' not in params or
                params['frequency_profile'] is None):
            raise ValueError("Missing the required parameter `frequency_profile` when calling `create_healthbot_ingest_settings_frequency_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'frequency_profile' in params:
            body_params = params['frequency_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/frequency-profile/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_tagging_profile_by_id(self, name, tagging_profile, **kwargs):  # noqa: E501
        """Create tagging-profile by ID  # noqa: E501

        Create operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profile_by_id(name, tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param TaggingProfileSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, tagging_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, tagging_profile, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(self, name, tagging_profile, **kwargs):  # noqa: E501
        """Create tagging-profile by ID  # noqa: E501

        Create operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param TaggingProfileSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'tagging_profile', 'x_iam_token']  # 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_healthbot_ingest_settings_tagging_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_settings_tagging_profile_by_id`")  # noqa: E501
        # verify the required parameter 'tagging_profile' is set
        if ('tagging_profile' not in params or
                params['tagging_profile'] is None):
            raise ValueError("Missing the required parameter `tagging_profile` when calling `create_healthbot_ingest_settings_tagging_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tagging_profile' in params:
            body_params = params['tagging_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/data-enrichment/tagging-profile/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_tagging_profiles(self, tagging_profile, **kwargs):  # noqa: E501
        """Create tagging-profile by ID  # noqa: E501

        Create operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profiles(tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaggingProfilesSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_settings_tagging_profiles_with_http_info(tagging_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_settings_tagging_profiles_with_http_info(tagging_profile, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_settings_tagging_profiles_with_http_info(self, tagging_profile, **kwargs):  # noqa: E501
        """Create tagging-profile by ID  # noqa: E501

        Create operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profiles_with_http_info(tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaggingProfilesSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['tagging_profile', 'x_iam_token']  # 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_healthbot_ingest_settings_tagging_profiles" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'tagging_profile' is set
        if ('tagging_profile' not in params or
                params['tagging_profile'] is None):
            raise ValueError("Missing the required parameter `tagging_profile` when calling `create_healthbot_ingest_settings_tagging_profiles`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tagging_profile' in params:
            body_params = params['tagging_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/data-enrichment/tagging-profiles/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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_healthbot_ingest_sflow(self, sflow, **kwargs):  # noqa: E501
        """Create sflow by ID  # noqa: E501

        Create operation of resource: sflow  # 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_healthbot_ingest_sflow(sflow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SflowSchema sflow: sflowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_sflow_with_http_info(sflow, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_sflow_with_http_info(sflow, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_sflow_with_http_info(self, sflow, **kwargs):  # noqa: E501
        """Create sflow by ID  # noqa: E501

        Create operation of resource: sflow  # 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_healthbot_ingest_sflow_with_http_info(sflow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SflowSchema sflow: sflowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sflow', 'x_iam_token']  # 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_healthbot_ingest_sflow" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'sflow' is set
        if ('sflow' not in params or
                params['sflow'] is None):
            raise ValueError("Missing the required parameter `sflow` when calling `create_healthbot_ingest_sflow`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'sflow' in params:
            body_params = params['sflow']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_counter_record_by_id(self, record_name, counter_record, **kwargs):  # noqa: E501
        """Create counter-record by ID  # noqa: E501

        Create operation of resource: counter-record  # 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_healthbot_ingest_sflow_counter_record_by_id(record_name, counter_record, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param CounterRecordSchema counter_record: counter_recordbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, counter_record, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, counter_record, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_sflow_counter_record_by_id_with_http_info(self, record_name, counter_record, **kwargs):  # noqa: E501
        """Create counter-record by ID  # noqa: E501

        Create operation of resource: counter-record  # 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_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, counter_record, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param CounterRecordSchema counter_record: counter_recordbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['record_name', 'counter_record', 'x_iam_token']  # 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_healthbot_ingest_sflow_counter_record_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'record_name' is set
        if ('record_name' not in params or
                params['record_name'] is None):
            raise ValueError("Missing the required parameter `record_name` when calling `create_healthbot_ingest_sflow_counter_record_by_id`")  # noqa: E501
        # verify the required parameter 'counter_record' is set
        if ('counter_record' not in params or
                params['counter_record'] is None):
            raise ValueError("Missing the required parameter `counter_record` when calling `create_healthbot_ingest_sflow_counter_record_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'record_name' in params:
            path_params['record_name'] = params['record_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'counter_record' in params:
            body_params = params['counter_record']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/counter-record/{record_name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_flow_record_by_id(self, record_name, flow_record, **kwargs):  # noqa: E501
        """Create flow-record by ID  # noqa: E501

        Create operation of resource: flow-record  # 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_healthbot_ingest_sflow_flow_record_by_id(record_name, flow_record, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param FlowRecordSchema flow_record: flow_recordbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, flow_record, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, flow_record, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_sflow_flow_record_by_id_with_http_info(self, record_name, flow_record, **kwargs):  # noqa: E501
        """Create flow-record by ID  # noqa: E501

        Create operation of resource: flow-record  # 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_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, flow_record, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param FlowRecordSchema flow_record: flow_recordbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['record_name', 'flow_record', 'x_iam_token']  # 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_healthbot_ingest_sflow_flow_record_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'record_name' is set
        if ('record_name' not in params or
                params['record_name'] is None):
            raise ValueError("Missing the required parameter `record_name` when calling `create_healthbot_ingest_sflow_flow_record_by_id`")  # noqa: E501
        # verify the required parameter 'flow_record' is set
        if ('flow_record' not in params or
                params['flow_record'] is None):
            raise ValueError("Missing the required parameter `flow_record` when calling `create_healthbot_ingest_sflow_flow_record_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'record_name' in params:
            path_params['record_name'] = params['record_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'flow_record' in params:
            body_params = params['flow_record']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/flow-record/{record_name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_protocol_by_id(self, protocol_name, protocol, **kwargs):  # noqa: E501
        """Create protocol by ID  # noqa: E501

        Create operation of resource: protocol  # 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_healthbot_ingest_sflow_protocol_by_id(protocol_name, protocol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str protocol_name: ID of protocol-name (required)
        :param ProtocolSchema protocol: protocolbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, protocol, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, protocol, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_sflow_protocol_by_id_with_http_info(self, protocol_name, protocol, **kwargs):  # noqa: E501
        """Create protocol by ID  # noqa: E501

        Create operation of resource: protocol  # 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_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, protocol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str protocol_name: ID of protocol-name (required)
        :param ProtocolSchema protocol: protocolbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['protocol_name', 'protocol', 'x_iam_token']  # 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_healthbot_ingest_sflow_protocol_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'protocol_name' is set
        if ('protocol_name' not in params or
                params['protocol_name'] is None):
            raise ValueError("Missing the required parameter `protocol_name` when calling `create_healthbot_ingest_sflow_protocol_by_id`")  # noqa: E501
        # verify the required parameter 'protocol' is set
        if ('protocol' not in params or
                params['protocol'] is None):
            raise ValueError("Missing the required parameter `protocol` when calling `create_healthbot_ingest_sflow_protocol_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'protocol_name' in params:
            path_params['protocol_name'] = params['protocol_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'protocol' in params:
            body_params = params['protocol']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/protocol/{protocol_name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_sample_by_id(self, sample_name, sample, **kwargs):  # noqa: E501
        """Create sample by ID  # noqa: E501

        Create operation of resource: sample  # 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_healthbot_ingest_sflow_sample_by_id(sample_name, sample, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sample_name: ID of sample-name (required)
        :param SampleSchema sample: samplebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, sample, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, sample, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_sflow_sample_by_id_with_http_info(self, sample_name, sample, **kwargs):  # noqa: E501
        """Create sample by ID  # noqa: E501

        Create operation of resource: sample  # 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_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, sample, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sample_name: ID of sample-name (required)
        :param SampleSchema sample: samplebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sample_name', 'sample', 'x_iam_token']  # 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_healthbot_ingest_sflow_sample_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'sample_name' is set
        if ('sample_name' not in params or
                params['sample_name'] is None):
            raise ValueError("Missing the required parameter `sample_name` when calling `create_healthbot_ingest_sflow_sample_by_id`")  # noqa: E501
        # verify the required parameter 'sample' is set
        if ('sample' not in params or
                params['sample'] is None):
            raise ValueError("Missing the required parameter `sample` when calling `create_healthbot_ingest_sflow_sample_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sample_name' in params:
            path_params['sample_name'] = params['sample_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'sample' in params:
            body_params = params['sample']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/sample/{sample_name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_snmp_notification(self, snmp_notification, **kwargs):  # noqa: E501
        """Create snmp-notification by ID  # noqa: E501

        Create operation of resource: snmp-notification  # 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_healthbot_ingest_snmp_notification(snmp_notification, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SnmpNotificationSchema snmp_notification: snmp_notification body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_snmp_notification_with_http_info(snmp_notification, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_snmp_notification_with_http_info(snmp_notification, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_snmp_notification_with_http_info(self, snmp_notification, **kwargs):  # noqa: E501
        """Create snmp-notification by ID  # noqa: E501

        Create operation of resource: snmp-notification  # 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_healthbot_ingest_snmp_notification_with_http_info(snmp_notification, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SnmpNotificationSchema snmp_notification: snmp_notification body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['snmp_notification', 'x_iam_token']  # 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_healthbot_ingest_snmp_notification" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'snmp_notification' is set
        if ('snmp_notification' not in params or
                params['snmp_notification'] is None):
            raise ValueError("Missing the required parameter `snmp_notification` when calling `create_healthbot_ingest_snmp_notification`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'snmp_notification' in params:
            body_params = params['snmp_notification']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id(self, name, usm_user, **kwargs):  # noqa: E501
        """Create SNMPv3 user by UserName(ID)  # noqa: E501

        Create operation of resource: snmp v3 usm user  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id(name, usm_user, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: User Name (required)
        :param Snmpv3UsmUserSchema usm_user: snmp_v3_usm user object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, usm_user, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, usm_user, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(self, name, usm_user, **kwargs):  # noqa: E501
        """Create SNMPv3 user by UserName(ID)  # noqa: E501

        Create operation of resource: snmp v3 usm user  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, usm_user, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: User Name (required)
        :param Snmpv3UsmUserSchema usm_user: snmp_v3_usm user object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'usm_user', 'x_iam_token']  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_snmp_notification_v3_usm_user_by_id`")  # noqa: E501
        # verify the required parameter 'usm_user' is set
        if ('usm_user' not in params or
                params['usm_user'] is None):
            raise ValueError("Missing the required parameter `usm_user` when calling `create_healthbot_ingest_snmp_notification_v3_usm_user_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'usm_user' in params:
            body_params = params['usm_user']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/v3/usm/user/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_syslog_header_pattern_by_id(self, name, pattern, **kwargs):  # noqa: E501
        """Create pattern by ID  # noqa: E501

        Create operation of resource: header-pattern  # 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_healthbot_ingest_syslog_header_pattern_by_id(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param HeaderPatternSchema pattern: header_patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(self, name, pattern, **kwargs):  # noqa: E501
        """Create pattern by ID  # noqa: E501

        Create operation of resource: header-pattern  # 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_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param HeaderPatternSchema pattern: header_patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern', 'x_iam_token']  # 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_healthbot_ingest_syslog_header_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_syslog_header_pattern_by_id`")  # noqa: E501
        # verify the required parameter 'pattern' is set
        if ('pattern' not in params or
                params['pattern'] is None):
            raise ValueError("Missing the required parameter `pattern` when calling `create_healthbot_ingest_syslog_header_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern' in params:
            body_params = params['pattern']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/header-pattern/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_tagging_profile_by_id(self, name, tagging_profile, **kwargs):  # noqa: E501
        """Create tagging-profile by ID  # noqa: E501

        Create operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profile_by_id(name, tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param TaggingProfileSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_tagging_profile_by_id_with_http_info(name, tagging_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_tagging_profile_by_id_with_http_info(name, tagging_profile, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_tagging_profile_by_id_with_http_info(self, name, tagging_profile, **kwargs):  # noqa: E501
        """Create tagging-profile by ID  # noqa: E501

        Create operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profile_by_id_with_http_info(name, tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param TaggingProfileSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'tagging_profile', 'x_iam_token']  # 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_healthbot_ingest_tagging_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_healthbot_ingest_tagging_profile_by_id`")  # noqa: E501
        # verify the required parameter 'tagging_profile' is set
        if ('tagging_profile' not in params or
                params['tagging_profile'] is None):
            raise ValueError("Missing the required parameter `tagging_profile` when calling `create_healthbot_ingest_tagging_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tagging_profile' in params:
            body_params = params['tagging_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/data-enrichment/tagging-profile/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_tagging_profiles(self, tagging_profile, **kwargs):  # noqa: E501
        """Create tagging-profile by ID  # noqa: E501

        Create operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profiles(tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaggingProfilesSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_ingest_tagging_profiles_with_http_info(tagging_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_ingest_tagging_profiles_with_http_info(tagging_profile, **kwargs)  # noqa: E501
            return data

    def create_healthbot_ingest_tagging_profiles_with_http_info(self, tagging_profile, **kwargs):  # noqa: E501
        """Create tagging-profile by ID  # noqa: E501

        Create operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profiles_with_http_info(tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaggingProfilesSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['tagging_profile', 'x_iam_token']  # 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_healthbot_ingest_tagging_profiles" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'tagging_profile' is set
        if ('tagging_profile' not in params or
                params['tagging_profile'] is None):
            raise ValueError("Missing the required parameter `tagging_profile` when calling `create_healthbot_ingest_tagging_profiles`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tagging_profile' in params:
            body_params = params['tagging_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/data-enrichment/tagging-profiles/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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_healthbot_organization_organization_by_id(self, organization_name, organization, **kwargs):  # noqa: E501
        """Create organization by ID  # noqa: E501

        Create operation of resource: organization  # 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_healthbot_organization_organization_by_id(organization_name, organization, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str organization_name: ID of organization-name (required)
        :param OrganizationSchema organization: organizationbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_organization_organization_by_id_with_http_info(organization_name, organization, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_organization_organization_by_id_with_http_info(organization_name, organization, **kwargs)  # noqa: E501
            return data

    def create_healthbot_organization_organization_by_id_with_http_info(self, organization_name, organization, **kwargs):  # noqa: E501
        """Create organization by ID  # noqa: E501

        Create operation of resource: organization  # 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_healthbot_organization_organization_by_id_with_http_info(organization_name, organization, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str organization_name: ID of organization-name (required)
        :param OrganizationSchema organization: organizationbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['organization_name', 'organization', 'x_iam_token']  # 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_healthbot_organization_organization_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'organization_name' is set
        if ('organization_name' not in params or
                params['organization_name'] is None):
            raise ValueError("Missing the required parameter `organization_name` when calling `create_healthbot_organization_organization_by_id`")  # noqa: E501
        # verify the required parameter 'organization' is set
        if ('organization' not in params or
                params['organization'] is None):
            raise ValueError("Missing the required parameter `organization` when calling `create_healthbot_organization_organization_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'organization_name' in params:
            path_params['organization_name'] = params['organization_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'organization' in params:
            body_params = params['organization']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/organization/{organization_name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id(self, profile_id, field_profile, **kwargs):  # noqa: E501
        """Create field-profile by ID  # noqa: E501

        Create operation of resource: field-profile  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id(profile_id, field_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str profile_id: ID of profile-id (required)
        :param RollupSummarizationSchema field_profile: field_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, field_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, field_profile, **kwargs)  # noqa: E501
            return data

    def create_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(self, profile_id, field_profile, **kwargs):  # noqa: E501
        """Create field-profile by ID  # noqa: E501

        Create operation of resource: field-profile  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, field_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str profile_id: ID of profile-id (required)
        :param RollupSummarizationSchema field_profile: field_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['profile_id', 'field_profile', 'x_iam_token']  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'profile_id' is set
        if ('profile_id' not in params or
                params['profile_id'] is None):
            raise ValueError("Missing the required parameter `profile_id` when calling `create_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id`")  # noqa: E501
        # verify the required parameter 'field_profile' is set
        if ('field_profile' not in params or
                params['field_profile'] is None):
            raise ValueError("Missing the required parameter `field_profile` when calling `create_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'profile_id' in params:
            path_params['profile_id'] = params['profile_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'field_profile' in params:
            body_params = params['field_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/rollup-summarization/field-profile/{profile_id}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_system_time_series_database_time_series_database_by_id(self, time_series_database, **kwargs):  # noqa: E501
        """Create time-series-database by ID  # noqa: E501

        Create operation of resource: time-series-database  # 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_healthbot_system_time_series_database_time_series_database_by_id(time_series_database, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TsdbSchema time_series_database: time_series_databasebody object (required)
        :param bool force_tsdb: force update tsdb when force is set to True
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(time_series_database, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(time_series_database, **kwargs)  # noqa: E501
            return data

    def create_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(self, time_series_database, **kwargs):  # noqa: E501
        """Create time-series-database by ID  # noqa: E501

        Create operation of resource: time-series-database  # 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_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(time_series_database, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TsdbSchema time_series_database: time_series_databasebody object (required)
        :param bool force_tsdb: force update tsdb when force is set to True
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['time_series_database', 'force_tsdb']  # 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_healthbot_system_time_series_database_time_series_database_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'time_series_database' is set
        if ('time_series_database' not in params or
                params['time_series_database'] is None):
            raise ValueError("Missing the required parameter `time_series_database` when calling `create_healthbot_system_time_series_database_time_series_database_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'force_tsdb' in params:
            query_params.append(('force_tsdb', params['force_tsdb']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'time_series_database' in params:
            body_params = params['time_series_database']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/system/tsdb/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_system_trigger_action(self, trigger_action, **kwargs):  # noqa: E501
        """Create trigger-action  # noqa: E501

        Create operation of resource: trigger-action  # 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_healthbot_system_trigger_action(trigger_action, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TriggerActionSchema trigger_action: trigger_action object (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_healthbot_system_trigger_action_with_http_info(trigger_action, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_system_trigger_action_with_http_info(trigger_action, **kwargs)  # noqa: E501
            return data

    def create_healthbot_system_trigger_action_with_http_info(self, trigger_action, **kwargs):  # noqa: E501
        """Create trigger-action  # noqa: E501

        Create operation of resource: trigger-action  # 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_healthbot_system_trigger_action_with_http_info(trigger_action, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TriggerActionSchema trigger_action: trigger_action object (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['trigger_action']  # 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_healthbot_system_trigger_action" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'trigger_action' is set
        if ('trigger_action' not in params or
                params['trigger_action'] is None):
            raise ValueError("Missing the required parameter `trigger_action` when calling `create_healthbot_system_trigger_action`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'trigger_action' in params:
            body_params = params['trigger_action']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/system/trigger_action/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest(self, ingest_settings, **kwargs):  # noqa: E501
        """Create ingest by ID  # noqa: E501

        Create operation of resource: ingest  # 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_iceberg_ingest(ingest_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IngestSettingsSchema ingest_settings: ingest_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_with_http_info(ingest_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_with_http_info(ingest_settings, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_with_http_info(self, ingest_settings, **kwargs):  # noqa: E501
        """Create ingest by ID  # noqa: E501

        Create operation of resource: ingest  # 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_iceberg_ingest_with_http_info(ingest_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IngestSettingsSchema ingest_settings: ingest_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['ingest_settings', 'x_iam_token']  # 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_iceberg_ingest" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'ingest_settings' is set
        if ('ingest_settings' not in params or
                params['ingest_settings'] is None):
            raise ValueError("Missing the required parameter `ingest_settings` when calling `create_iceberg_ingest`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ingest_settings' in params:
            body_params = params['ingest_settings']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_flow(self, flow, **kwargs):  # noqa: E501
        """Create flow by ID  # noqa: E501

        Create operation of resource: flow  # 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_iceberg_ingest_flow(flow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FlowSchema flow: flowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_flow_with_http_info(flow, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_flow_with_http_info(flow, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_flow_with_http_info(self, flow, **kwargs):  # noqa: E501
        """Create flow by ID  # noqa: E501

        Create operation of resource: flow  # 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_iceberg_ingest_flow_with_http_info(flow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FlowSchema flow: flowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['flow', 'x_iam_token']  # 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_iceberg_ingest_flow" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'flow' is set
        if ('flow' not in params or
                params['flow'] is None):
            raise ValueError("Missing the required parameter `flow` when calling `create_iceberg_ingest_flow`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'flow' in params:
            body_params = params['flow']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_flow_template_by_id(self, name, template, **kwargs):  # noqa: E501
        """Create template by ID  # noqa: E501

        Create operation of resource: template  # 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_iceberg_ingest_flow_template_by_id(name, template, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param TemplateSchema template: templatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_flow_template_by_id_with_http_info(name, template, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_flow_template_by_id_with_http_info(name, template, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_flow_template_by_id_with_http_info(self, name, template, **kwargs):  # noqa: E501
        """Create template by ID  # noqa: E501

        Create operation of resource: template  # 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_iceberg_ingest_flow_template_by_id_with_http_info(name, template, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param TemplateSchema template: templatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'template', 'x_iam_token']  # 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_iceberg_ingest_flow_template_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_ingest_flow_template_by_id`")  # noqa: E501
        # verify the required parameter 'template' is set
        if ('template' not in params or
                params['template'] is None):
            raise ValueError("Missing the required parameter `template` when calling `create_iceberg_ingest_flow_template_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'template' in params:
            body_params = params['template']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/template/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_native_gpb(self, native_gpb, **kwargs):  # noqa: E501
        """Create native-gpb by ID  # noqa: E501

        Create operation of resource: native-gpb  # 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_iceberg_ingest_native_gpb(native_gpb, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NativeGpbSchema native_gpb: native_gpbbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_native_gpb_with_http_info(native_gpb, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_native_gpb_with_http_info(native_gpb, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_native_gpb_with_http_info(self, native_gpb, **kwargs):  # noqa: E501
        """Create native-gpb by ID  # noqa: E501

        Create operation of resource: native-gpb  # 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_iceberg_ingest_native_gpb_with_http_info(native_gpb, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NativeGpbSchema native_gpb: native_gpbbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['native_gpb', 'x_iam_token']  # 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_iceberg_ingest_native_gpb" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'native_gpb' is set
        if ('native_gpb' not in params or
                params['native_gpb'] is None):
            raise ValueError("Missing the required parameter `native_gpb` when calling `create_iceberg_ingest_native_gpb`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'native_gpb' in params:
            body_params = params['native_gpb']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/native-gpb/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings(self, ingest_settings, **kwargs):  # noqa: E501
        """Create ingest-settings by ID  # noqa: E501

        Create operation of resource: ingest-settings  # 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_iceberg_ingest_settings(ingest_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IngestSettingsSchema ingest_settings: ingest_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_settings_with_http_info(ingest_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_settings_with_http_info(ingest_settings, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_settings_with_http_info(self, ingest_settings, **kwargs):  # noqa: E501
        """Create ingest-settings by ID  # noqa: E501

        Create operation of resource: ingest-settings  # 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_iceberg_ingest_settings_with_http_info(ingest_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IngestSettingsSchema ingest_settings: ingest_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['ingest_settings', 'x_iam_token']  # 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_iceberg_ingest_settings" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'ingest_settings' is set
        if ('ingest_settings' not in params or
                params['ingest_settings'] is None):
            raise ValueError("Missing the required parameter `ingest_settings` when calling `create_iceberg_ingest_settings`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ingest_settings' in params:
            body_params = params['ingest_settings']
        # 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', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_flow(self, flow, **kwargs):  # noqa: E501
        """Create flow by ID  # noqa: E501

        Create operation of resource: flow  # 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_iceberg_ingest_settings_flow(flow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FlowSchema flow: flowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_settings_flow_with_http_info(flow, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_settings_flow_with_http_info(flow, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_settings_flow_with_http_info(self, flow, **kwargs):  # noqa: E501
        """Create flow by ID  # noqa: E501

        Create operation of resource: flow  # 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_iceberg_ingest_settings_flow_with_http_info(flow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FlowSchema flow: flowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['flow', 'x_iam_token']  # 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_iceberg_ingest_settings_flow" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'flow' is set
        if ('flow' not in params or
                params['flow'] is None):
            raise ValueError("Missing the required parameter `flow` when calling `create_iceberg_ingest_settings_flow`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'flow' in params:
            body_params = params['flow']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_flow_template_by_id(self, name, template, **kwargs):  # noqa: E501
        """Create template by ID  # noqa: E501

        Create operation of resource: template  # 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_iceberg_ingest_settings_flow_template_by_id(name, template, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param TemplateSchema template: templatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, template, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, template, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_settings_flow_template_by_id_with_http_info(self, name, template, **kwargs):  # noqa: E501
        """Create template by ID  # noqa: E501

        Create operation of resource: template  # 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_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, template, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param TemplateSchema template: templatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'template', 'x_iam_token']  # 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_iceberg_ingest_settings_flow_template_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_ingest_settings_flow_template_by_id`")  # noqa: E501
        # verify the required parameter 'template' is set
        if ('template' not in params or
                params['template'] is None):
            raise ValueError("Missing the required parameter `template` when calling `create_iceberg_ingest_settings_flow_template_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'template' in params:
            body_params = params['template']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/template/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog(self, syslog, **kwargs):  # noqa: E501
        """Create syslog by ID  # noqa: E501

        Create operation of resource: syslog  # 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_iceberg_ingest_settings_syslog(syslog, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SyslogSchema syslog: syslogbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_settings_syslog_with_http_info(syslog, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_settings_syslog_with_http_info(syslog, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_settings_syslog_with_http_info(self, syslog, **kwargs):  # noqa: E501
        """Create syslog by ID  # noqa: E501

        Create operation of resource: syslog  # 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_iceberg_ingest_settings_syslog_with_http_info(syslog, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SyslogSchema syslog: syslogbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['syslog', 'x_iam_token']  # 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_iceberg_ingest_settings_syslog" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'syslog' is set
        if ('syslog' not in params or
                params['syslog'] is None):
            raise ValueError("Missing the required parameter `syslog` when calling `create_iceberg_ingest_settings_syslog`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'syslog' in params:
            body_params = params['syslog']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog_pattern_by_id(self, name, pattern, **kwargs):  # noqa: E501
        """Create pattern by ID  # noqa: E501

        Create operation of resource: pattern  # 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_iceberg_ingest_settings_syslog_pattern_by_id(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param PatternSchema pattern: patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(self, name, pattern, **kwargs):  # noqa: E501
        """Create pattern by ID  # noqa: E501

        Create operation of resource: pattern  # 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_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param PatternSchema pattern: patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern', 'x_iam_token']  # 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_iceberg_ingest_settings_syslog_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_ingest_settings_syslog_pattern_by_id`")  # noqa: E501
        # verify the required parameter 'pattern' is set
        if ('pattern' not in params or
                params['pattern'] is None):
            raise ValueError("Missing the required parameter `pattern` when calling `create_iceberg_ingest_settings_syslog_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern' in params:
            body_params = params['pattern']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id(self, name, pattern_set, **kwargs):  # noqa: E501
        """Create pattern-set by ID  # noqa: E501

        Create operation of resource: pattern-set  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id(name, pattern_set, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param PatternSetSchema pattern_set: pattern_setbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, pattern_set, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, pattern_set, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(self, name, pattern_set, **kwargs):  # noqa: E501
        """Create pattern-set by ID  # noqa: E501

        Create operation of resource: pattern-set  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, pattern_set, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param PatternSetSchema pattern_set: pattern_setbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern_set', 'x_iam_token']  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_ingest_settings_syslog_pattern_set_by_id`")  # noqa: E501
        # verify the required parameter 'pattern_set' is set
        if ('pattern_set' not in params or
                params['pattern_set'] is None):
            raise ValueError("Missing the required parameter `pattern_set` when calling `create_iceberg_ingest_settings_syslog_pattern_set_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern_set' in params:
            body_params = params['pattern_set']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern-set/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog(self, syslog, **kwargs):  # noqa: E501
        """Create syslog by ID  # noqa: E501

        Create operation of resource: syslog  # 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_iceberg_ingest_syslog(syslog, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SyslogSchema syslog: syslogbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_syslog_with_http_info(syslog, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_syslog_with_http_info(syslog, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_syslog_with_http_info(self, syslog, **kwargs):  # noqa: E501
        """Create syslog by ID  # noqa: E501

        Create operation of resource: syslog  # 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_iceberg_ingest_syslog_with_http_info(syslog, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SyslogSchema syslog: syslogbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['syslog', 'x_iam_token']  # 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_iceberg_ingest_syslog" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'syslog' is set
        if ('syslog' not in params or
                params['syslog'] is None):
            raise ValueError("Missing the required parameter `syslog` when calling `create_iceberg_ingest_syslog`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'syslog' in params:
            body_params = params['syslog']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog_pattern_by_id(self, name, pattern, **kwargs):  # noqa: E501
        """Create pattern by ID  # noqa: E501

        Create operation of resource: pattern  # 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_iceberg_ingest_syslog_pattern_by_id(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param PatternSchema pattern: patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_syslog_pattern_by_id_with_http_info(self, name, pattern, **kwargs):  # noqa: E501
        """Create pattern by ID  # noqa: E501

        Create operation of resource: pattern  # 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_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param PatternSchema pattern: patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern', 'x_iam_token']  # 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_iceberg_ingest_syslog_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_ingest_syslog_pattern_by_id`")  # noqa: E501
        # verify the required parameter 'pattern' is set
        if ('pattern' not in params or
                params['pattern'] is None):
            raise ValueError("Missing the required parameter `pattern` when calling `create_iceberg_ingest_syslog_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern' in params:
            body_params = params['pattern']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog_pattern_set_by_id(self, name, pattern_set, **kwargs):  # noqa: E501
        """Create pattern-set by ID  # noqa: E501

        Create operation of resource: pattern-set  # 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_iceberg_ingest_syslog_pattern_set_by_id(name, pattern_set, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param PatternSetSchema pattern_set: pattern_setbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, pattern_set, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, pattern_set, **kwargs)  # noqa: E501
            return data

    def create_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(self, name, pattern_set, **kwargs):  # noqa: E501
        """Create pattern-set by ID  # noqa: E501

        Create operation of resource: pattern-set  # 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_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, pattern_set, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param PatternSetSchema pattern_set: pattern_setbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern_set', 'x_iam_token']  # 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_iceberg_ingest_syslog_pattern_set_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_ingest_syslog_pattern_set_by_id`")  # noqa: E501
        # verify the required parameter 'pattern_set' is set
        if ('pattern_set' not in params or
                params['pattern_set'] is None):
            raise ValueError("Missing the required parameter `pattern_set` when calling `create_iceberg_ingest_syslog_pattern_set_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern_set' in params:
            body_params = params['pattern_set']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern-set/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_data_summarization_raw_by_id(self, name, raw_data_summarization, **kwargs):  # noqa: E501
        """Create raw-data-summarization by ID  # noqa: E501

        Create operation of resource: raw-data-summarization  # 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_iceberg_profile_data_summarization_raw_by_id(name, raw_data_summarization, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of raw-data-summarization (required)
        :param RawSchema raw_data_summarization: raw_data_summarizationbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, raw_data_summarization, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, raw_data_summarization, **kwargs)  # noqa: E501
            return data

    def create_iceberg_profile_data_summarization_raw_by_id_with_http_info(self, name, raw_data_summarization, **kwargs):  # noqa: E501
        """Create raw-data-summarization by ID  # noqa: E501

        Create operation of resource: raw-data-summarization  # 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_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, raw_data_summarization, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of raw-data-summarization (required)
        :param RawSchema raw_data_summarization: raw_data_summarizationbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'raw_data_summarization', 'x_iam_token']  # 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_iceberg_profile_data_summarization_raw_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_profile_data_summarization_raw_by_id`")  # noqa: E501
        # verify the required parameter 'raw_data_summarization' is set
        if ('raw_data_summarization' not in params or
                params['raw_data_summarization'] is None):
            raise ValueError("Missing the required parameter `raw_data_summarization` when calling `create_iceberg_profile_data_summarization_raw_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'raw_data_summarization' in params:
            body_params = params['raw_data_summarization']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/data-summarization/raw/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_ca_profile_by_id(self, name, ca_profile, **kwargs):  # noqa: E501
        """Create ca-profile by ID  # noqa: E501

        Create operation of resource: ca-profile  # 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_iceberg_profile_security_ca_profile_by_id(name, ca_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ca-profile (required)
        :param CaProfileSchema ca_profile: ca_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_profile_security_ca_profile_by_id_with_http_info(name, ca_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_profile_security_ca_profile_by_id_with_http_info(name, ca_profile, **kwargs)  # noqa: E501
            return data

    def create_iceberg_profile_security_ca_profile_by_id_with_http_info(self, name, ca_profile, **kwargs):  # noqa: E501
        """Create ca-profile by ID  # noqa: E501

        Create operation of resource: ca-profile  # 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_iceberg_profile_security_ca_profile_by_id_with_http_info(name, ca_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ca-profile (required)
        :param CaProfileSchema ca_profile: ca_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'ca_profile', 'x_iam_token']  # 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_iceberg_profile_security_ca_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_profile_security_ca_profile_by_id`")  # noqa: E501
        # verify the required parameter 'ca_profile' is set
        if ('ca_profile' not in params or
                params['ca_profile'] is None):
            raise ValueError("Missing the required parameter `ca_profile` when calling `create_iceberg_profile_security_ca_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ca_profile' in params:
            body_params = params['ca_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ca-profile/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_local_certificate_by_id(self, name, local_certificate, **kwargs):  # noqa: E501
        """Create local-certificate by ID  # noqa: E501

        Create operation of resource: local-certificate  # 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_iceberg_profile_security_local_certificate_by_id(name, local_certificate, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of local-certificate (required)
        :param LocalCertificateSchema local_certificate: local_certificatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_profile_security_local_certificate_by_id_with_http_info(name, local_certificate, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_profile_security_local_certificate_by_id_with_http_info(name, local_certificate, **kwargs)  # noqa: E501
            return data

    def create_iceberg_profile_security_local_certificate_by_id_with_http_info(self, name, local_certificate, **kwargs):  # noqa: E501
        """Create local-certificate by ID  # noqa: E501

        Create operation of resource: local-certificate  # 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_iceberg_profile_security_local_certificate_by_id_with_http_info(name, local_certificate, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of local-certificate (required)
        :param LocalCertificateSchema local_certificate: local_certificatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'local_certificate', 'x_iam_token']  # 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_iceberg_profile_security_local_certificate_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_profile_security_local_certificate_by_id`")  # noqa: E501
        # verify the required parameter 'local_certificate' is set
        if ('local_certificate' not in params or
                params['local_certificate'] is None):
            raise ValueError("Missing the required parameter `local_certificate` when calling `create_iceberg_profile_security_local_certificate_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'local_certificate' in params:
            body_params = params['local_certificate']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/local-certificate/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_ssh_key_profile_by_id(self, name, ssh_key_profile, **kwargs):  # noqa: E501
        """Create ssh-key-profile by ID  # noqa: E501

        Create operation of resource: ssh-key-profile  # 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_iceberg_profile_security_ssh_key_profile_by_id(name, ssh_key_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ssh-key-profile (required)
        :param SshKeyProfileSchema ssh_key_profile: ssh_key_profilebody object (required)
        :param str authorization: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, ssh_key_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, ssh_key_profile, **kwargs)  # noqa: E501
            return data

    def create_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(self, name, ssh_key_profile, **kwargs):  # noqa: E501
        """Create ssh-key-profile by ID  # noqa: E501

        Create operation of resource: ssh-key-profile  # 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_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, ssh_key_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ssh-key-profile (required)
        :param SshKeyProfileSchema ssh_key_profile: ssh_key_profilebody object (required)
        :param str authorization: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'ssh_key_profile', 'authorization']  # 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_iceberg_profile_security_ssh_key_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `create_iceberg_profile_security_ssh_key_profile_by_id`")  # noqa: E501
        # verify the required parameter 'ssh_key_profile' is set
        if ('ssh_key_profile' not in params or
                params['ssh_key_profile'] is None):
            raise ValueError("Missing the required parameter `ssh_key_profile` when calling `create_iceberg_profile_security_ssh_key_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ssh_key_profile' in params:
            body_params = params['ssh_key_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ssh-key-profile/{name}/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profiles(self, profile, **kwargs):  # noqa: E501
        """Create profile by ID  # noqa: E501

        Create entire profile configuration.  # 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_iceberg_profiles(profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ProfilesSchema profile: profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_iceberg_profiles_with_http_info(profile, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_profiles_with_http_info(profile, **kwargs)  # noqa: E501
            return data

    def create_iceberg_profiles_with_http_info(self, profile, **kwargs):  # noqa: E501
        """Create profile by ID  # noqa: E501

        Create entire profile configuration.  # 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_iceberg_profiles_with_http_info(profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ProfilesSchema profile: profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['profile', 'x_iam_token']  # 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_iceberg_profiles" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'profile' is set
        if ('profile' not in params or
                params['profile'] is None):
            raise ValueError("Missing the required parameter `profile` when calling `create_iceberg_profiles`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'profile' in params:
            body_params = params['profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profiles/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_dynamic_tagging_by_key(self, key_name, **kwargs):  # noqa: E501
        """Delete Dynamic-tagging key-value  # noqa: E501

        Update a key in Dynamic-tagging  # 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_dynamic_tagging_by_key(key_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str key_name: Dynamic-tagging Key (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_dynamic_tagging_by_key_with_http_info(key_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_dynamic_tagging_by_key_with_http_info(key_name, **kwargs)  # noqa: E501
            return data

    def delete_dynamic_tagging_by_key_with_http_info(self, key_name, **kwargs):  # noqa: E501
        """Delete Dynamic-tagging key-value  # noqa: E501

        Update a key in Dynamic-tagging  # 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_dynamic_tagging_by_key_with_http_info(key_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str key_name: Dynamic-tagging Key (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['key_name', 'x_iam_token']  # 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_dynamic_tagging_by_key" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'key_name' is set
        if ('key_name' not in params or
                params['key_name'] is None):
            raise ValueError("Missing the required parameter `key_name` when calling `delete_dynamic_tagging_by_key`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'key_name' in params:
            query_params.append(('key_name', params['key_name']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/dynamic-tagging/key/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_files_certificates_by_file_name(self, file_name, **kwargs):  # noqa: E501
        """Delete a certificate-file.  # noqa: E501

        Delete the specified certificate-file. Delete will not fail if the certificate-file is being used by some service.  # 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_files_certificates_by_file_name(file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :param str certificate_type: Certificate type
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_files_certificates_by_file_name_with_http_info(file_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_files_certificates_by_file_name_with_http_info(file_name, **kwargs)  # noqa: E501
            return data

    def delete_files_certificates_by_file_name_with_http_info(self, file_name, **kwargs):  # noqa: E501
        """Delete a certificate-file.  # noqa: E501

        Delete the specified certificate-file. Delete will not fail if the certificate-file is being used by some service.  # 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_files_certificates_by_file_name_with_http_info(file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :param str certificate_type: Certificate type
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['file_name', 'x_iam_token', 'input_path', 'certificate_type']  # 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_files_certificates_by_file_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'file_name' is set
        if ('file_name' not in params or
                params['file_name'] is None):
            raise ValueError("Missing the required parameter `file_name` when calling `delete_files_certificates_by_file_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'file_name' in params:
            path_params['file_name'] = params['file_name']  # noqa: E501

        query_params = []
        if 'input_path' in params:
            query_params.append(('input_path', params['input_path']))  # noqa: E501
        if 'certificate_type' in params:
            query_params.append(('certificate_type', params['certificate_type']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/certificates/{file_name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_files_helper_files_by_file_name(self, file_name, **kwargs):  # noqa: E501
        """Delete a helper-file.  # noqa: E501

        Delete the specified helper-file. Delete will not fail if the helper-file is being used by some service.  # 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_files_helper_files_by_file_name(file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_files_helper_files_by_file_name_with_http_info(file_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_files_helper_files_by_file_name_with_http_info(file_name, **kwargs)  # noqa: E501
            return data

    def delete_files_helper_files_by_file_name_with_http_info(self, file_name, **kwargs):  # noqa: E501
        """Delete a helper-file.  # noqa: E501

        Delete the specified helper-file. Delete will not fail if the helper-file is being used by some service.  # 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_files_helper_files_by_file_name_with_http_info(file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['file_name', 'x_iam_token', 'input_path']  # 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_files_helper_files_by_file_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'file_name' is set
        if ('file_name' not in params or
                params['file_name'] is None):
            raise ValueError("Missing the required parameter `file_name` when calling `delete_files_helper_files_by_file_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'file_name' in params:
            path_params['file_name'] = params['file_name']  # noqa: E501

        query_params = []
        if 'input_path' in params:
            query_params.append(('input_path', params['input_path']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/helper-files/{file_name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_deployment_deployment_by_id(self, **kwargs):  # noqa: E501
        """Delete deployment by ID  # noqa: E501

        Delete operation of resource: deployment  # 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_healthbot_deployment_deployment_by_id(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_deployment_deployment_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_deployment_deployment_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_deployment_deployment_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete deployment by ID  # noqa: E501

        Delete operation of resource: deployment  # 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_healthbot_deployment_deployment_by_id_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_healthbot_deployment_deployment_by_id" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/deployment/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_dynamic_tagging(self, **kwargs):  # noqa: E501
        """Delete dynamic-tagging by ID  # noqa: E501

        Delete operation of resource: dynamic-tagging  # 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_healthbot_dynamic_tagging(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_dynamic_tagging_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_dynamic_tagging_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_dynamic_tagging_with_http_info(self, **kwargs):  # noqa: E501
        """Delete dynamic-tagging by ID  # noqa: E501

        Delete operation of resource: dynamic-tagging  # 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_healthbot_dynamic_tagging_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_healthbot_dynamic_tagging" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/dynamic-tagging/keys/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_byoi_custom_plugin_by_id(self, name, **kwargs):  # noqa: E501
        """Delete custom-plugin by ID  # noqa: E501

        Delete operation of resource: custom-plugin  # 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_healthbot_ingest_byoi_custom_plugin_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete custom-plugin by ID  # noqa: E501

        Delete operation of resource: custom-plugin  # 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_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_byoi_custom_plugin_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_byoi_custom_plugin_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/custom-plugin/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id(self, name, **kwargs):  # noqa: E501
        """Delete tlive-kafka-oc by ID  # noqa: E501

        Delete operation of resource: tlive-kafka-oc  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete tlive-kafka-oc by ID  # noqa: E501

        Delete operation of resource: tlive-kafka-oc  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/default-plugin/tlive-kafka-oc/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_byoi_ingest_mapping_by_id(self, name, **kwargs):  # noqa: E501
        """Delete ingest-mapping by ID  # noqa: E501

        Delete ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_healthbot_ingest_byoi_ingest_mapping_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete ingest-mapping by ID  # noqa: E501

        Delete ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_byoi_ingest_mapping_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_byoi_ingest_mapping_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/ingest-mapping/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_frequency_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Delete frequency-profile by ID  # noqa: E501

        Delete operation of resource: frequency-profile  # 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_healthbot_ingest_frequency_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_frequency_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_frequency_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_frequency_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete frequency-profile by ID  # noqa: E501

        Delete operation of resource: frequency-profile  # 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_healthbot_ingest_frequency_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_frequency_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_frequency_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/frequency-profile/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_outbound_ssh(self, **kwargs):  # noqa: E501
        """Delete outbound-ssh by ID  # noqa: E501

        Delete operation of resource: outbound-ssh  # 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_healthbot_ingest_outbound_ssh(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_outbound_ssh_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_outbound_ssh_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_outbound_ssh_with_http_info(self, **kwargs):  # noqa: E501
        """Delete outbound-ssh by ID  # noqa: E501

        Delete operation of resource: outbound-ssh  # 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_healthbot_ingest_outbound_ssh_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_healthbot_ingest_outbound_ssh" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/outbound-ssh/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id(self, name, **kwargs):  # noqa: E501
        """Delete custom-plugin by ID  # noqa: E501

        Delete operation of resource: custom-plugin  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete custom-plugin by ID  # noqa: E501

        Delete operation of resource: custom-plugin  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_settings_byoi_custom_plugin_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/custom-plugin/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id(self, name, **kwargs):  # noqa: E501
        """Delete tlive-kafka-oc by ID  # noqa: E501

        Delete operation of resource: tlive-kafka-oc  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete tlive-kafka-oc by ID  # noqa: E501

        Delete operation of resource: tlive-kafka-oc  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/default-plugin/tlive-kafka-oc/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_ingest_mapping_by_id(self, name, **kwargs):  # noqa: E501
        """Delete ingest-mapping by ID  # noqa: E501

        Delete ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_healthbot_ingest_settings_byoi_ingest_mapping_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete ingest-mapping by ID  # noqa: E501

        Delete ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_ingest_mapping_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_settings_byoi_ingest_mapping_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/ingest-mapping/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_frequency_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Delete frequency-profile by ID  # noqa: E501

        Delete operation of resource: frequency-profile  # 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_healthbot_ingest_settings_frequency_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete frequency-profile by ID  # noqa: E501

        Delete operation of resource: frequency-profile  # 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_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_settings_frequency_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_settings_frequency_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/frequency-profile/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_tagging_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Delete tagging-profile by ID  # noqa: E501

        Delete operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete tagging-profile by ID  # noqa: E501

        Delete operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_settings_tagging_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_settings_tagging_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/data-enrichment/tagging-profile/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_tagging_profiles(self, **kwargs):  # noqa: E501
        """Delete tagging-profile by ID  # noqa: E501

        Delete operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_settings_tagging_profiles_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_settings_tagging_profiles_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_settings_tagging_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """Delete tagging-profile by ID  # noqa: E501

        Delete operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_healthbot_ingest_settings_tagging_profiles" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/data-enrichment/tagging-profiles/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow(self, **kwargs):  # noqa: E501
        """Delete sflow by ID  # noqa: E501

        Delete operation of resource: sflow  # 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_healthbot_ingest_sflow(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_sflow_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_sflow_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_sflow_with_http_info(self, **kwargs):  # noqa: E501
        """Delete sflow by ID  # noqa: E501

        Delete operation of resource: sflow  # 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_healthbot_ingest_sflow_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_healthbot_ingest_sflow" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_counter_record_by_id(self, record_name, **kwargs):  # noqa: E501
        """Delete counter-record by ID  # noqa: E501

        Delete operation of resource: counter-record  # 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_healthbot_ingest_sflow_counter_record_by_id(record_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_sflow_counter_record_by_id_with_http_info(self, record_name, **kwargs):  # noqa: E501
        """Delete counter-record by ID  # noqa: E501

        Delete operation of resource: counter-record  # 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_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['record_name', 'x_iam_token']  # 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_healthbot_ingest_sflow_counter_record_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'record_name' is set
        if ('record_name' not in params or
                params['record_name'] is None):
            raise ValueError("Missing the required parameter `record_name` when calling `delete_healthbot_ingest_sflow_counter_record_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'record_name' in params:
            path_params['record_name'] = params['record_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/counter-record/{record_name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_flow_record_by_id(self, record_name, **kwargs):  # noqa: E501
        """Delete flow-record by ID  # noqa: E501

        Delete operation of resource: flow-record  # 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_healthbot_ingest_sflow_flow_record_by_id(record_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_sflow_flow_record_by_id_with_http_info(self, record_name, **kwargs):  # noqa: E501
        """Delete flow-record by ID  # noqa: E501

        Delete operation of resource: flow-record  # 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_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['record_name', 'x_iam_token']  # 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_healthbot_ingest_sflow_flow_record_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'record_name' is set
        if ('record_name' not in params or
                params['record_name'] is None):
            raise ValueError("Missing the required parameter `record_name` when calling `delete_healthbot_ingest_sflow_flow_record_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'record_name' in params:
            path_params['record_name'] = params['record_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/flow-record/{record_name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_protocol_by_id(self, protocol_name, **kwargs):  # noqa: E501
        """Delete protocol by ID  # noqa: E501

        Delete operation of resource: protocol  # 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_healthbot_ingest_sflow_protocol_by_id(protocol_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str protocol_name: ID of protocol-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_sflow_protocol_by_id_with_http_info(self, protocol_name, **kwargs):  # noqa: E501
        """Delete protocol by ID  # noqa: E501

        Delete operation of resource: protocol  # 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_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str protocol_name: ID of protocol-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['protocol_name', 'x_iam_token']  # 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_healthbot_ingest_sflow_protocol_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'protocol_name' is set
        if ('protocol_name' not in params or
                params['protocol_name'] is None):
            raise ValueError("Missing the required parameter `protocol_name` when calling `delete_healthbot_ingest_sflow_protocol_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'protocol_name' in params:
            path_params['protocol_name'] = params['protocol_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/protocol/{protocol_name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_sample_by_id(self, sample_name, **kwargs):  # noqa: E501
        """Delete sample by ID  # noqa: E501

        Delete operation of resource: sample  # 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_healthbot_ingest_sflow_sample_by_id(sample_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sample_name: ID of sample-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_sflow_sample_by_id_with_http_info(self, sample_name, **kwargs):  # noqa: E501
        """Delete sample by ID  # noqa: E501

        Delete operation of resource: sample  # 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_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sample_name: ID of sample-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sample_name', 'x_iam_token']  # 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_healthbot_ingest_sflow_sample_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'sample_name' is set
        if ('sample_name' not in params or
                params['sample_name'] is None):
            raise ValueError("Missing the required parameter `sample_name` when calling `delete_healthbot_ingest_sflow_sample_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sample_name' in params:
            path_params['sample_name'] = params['sample_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/sample/{sample_name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_snmp_notification(self, **kwargs):  # noqa: E501
        """Delete snmp-notification  # noqa: E501

        Delete operation of resource: snmp-notification  # 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_healthbot_ingest_snmp_notification(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_snmp_notification_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_snmp_notification_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_snmp_notification_with_http_info(self, **kwargs):  # noqa: E501
        """Delete snmp-notification  # noqa: E501

        Delete operation of resource: snmp-notification  # 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_healthbot_ingest_snmp_notification_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_healthbot_ingest_snmp_notification" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id(self, name, **kwargs):  # noqa: E501
        """Delete SNMPv3 user by UserName(ID)  # noqa: E501

        Delete operation of resource: snmp v3 usm user  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: User Name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete SNMPv3 user by UserName(ID)  # noqa: E501

        Delete operation of resource: snmp v3 usm user  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: User Name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_snmp_notification_v3_usm_user_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/v3/usm/user/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_syslog_header_pattern_by_id(self, name, **kwargs):  # noqa: E501
        """Delete pattern by ID  # noqa: E501

        Delete operation of resource: header-pattern  # 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_healthbot_ingest_syslog_header_pattern_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete pattern by ID  # noqa: E501

        Delete operation of resource: header-pattern  # 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_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_syslog_header_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_syslog_header_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/header-pattern/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_tagging_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Delete tagging-profile by ID  # noqa: E501

        Delete operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_tagging_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_tagging_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_tagging_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete tagging-profile by ID  # noqa: E501

        Delete operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_healthbot_ingest_tagging_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_healthbot_ingest_tagging_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/data-enrichment/tagging-profile/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_tagging_profiles(self, **kwargs):  # noqa: E501
        """Delete tagging-profile by ID  # noqa: E501

        Delete operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_ingest_tagging_profiles_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_tagging_profiles_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_tagging_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """Delete tagging-profile by ID  # noqa: E501

        Delete operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_healthbot_ingest_tagging_profiles" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/data-enrichment/tagging-profiles/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_organization_organization_by_id(self, organization_name, **kwargs):  # noqa: E501
        """Delete organization by ID  # noqa: E501

        Delete operation of resource: organization  # 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_healthbot_organization_organization_by_id(organization_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str organization_name: ID of organization-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_organization_organization_by_id_with_http_info(organization_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_organization_organization_by_id_with_http_info(organization_name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_organization_organization_by_id_with_http_info(self, organization_name, **kwargs):  # noqa: E501
        """Delete organization by ID  # noqa: E501

        Delete operation of resource: organization  # 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_healthbot_organization_organization_by_id_with_http_info(organization_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str organization_name: ID of organization-name (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['organization_name', 'x_iam_token']  # 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_healthbot_organization_organization_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'organization_name' is set
        if ('organization_name' not in params or
                params['organization_name'] is None):
            raise ValueError("Missing the required parameter `organization_name` when calling `delete_healthbot_organization_organization_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'organization_name' in params:
            path_params['organization_name'] = params['organization_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/organization/{organization_name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id(self, profile_id, **kwargs):  # noqa: E501
        """Delete field-profile by ID  # noqa: E501

        Delete operation of resource: field-profile  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id(profile_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str profile_id: ID of profile-id (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(self, profile_id, **kwargs):  # noqa: E501
        """Delete field-profile by ID  # noqa: E501

        Delete operation of resource: field-profile  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str profile_id: ID of profile-id (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['profile_id', 'x_iam_token']  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'profile_id' is set
        if ('profile_id' not in params or
                params['profile_id'] is None):
            raise ValueError("Missing the required parameter `profile_id` when calling `delete_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'profile_id' in params:
            path_params['profile_id'] = params['profile_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/rollup-summarization/field-profile/{profile_id}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_system_time_series_database_time_series_database_by_id(self, **kwargs):  # noqa: E501
        """Delete time-series-database  # noqa: E501

        Delete operation of resource: time-series-database  # 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_healthbot_system_time_series_database_time_series_database_by_id(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete time-series-database  # noqa: E501

        Delete operation of resource: time-series-database  # 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_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # 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_healthbot_system_time_series_database_time_series_database_by_id" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/system/tsdb/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_system_trigger_action(self, **kwargs):  # noqa: E501
        """Delete trigger-action schedulers  # noqa: E501

        Delete operation of resource: trigger-action  # 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_healthbot_system_trigger_action(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_healthbot_system_trigger_action_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_system_trigger_action_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_system_trigger_action_with_http_info(self, **kwargs):  # noqa: E501
        """Delete trigger-action schedulers  # noqa: E501

        Delete operation of resource: trigger-action  # 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_healthbot_system_trigger_action_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # 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_healthbot_system_trigger_action" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/system/trigger_action/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest(self, **kwargs):  # noqa: E501
        """Delete ingest by ID  # noqa: E501

        Delete operation of resource: ingest  # 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_iceberg_ingest(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_with_http_info(self, **kwargs):  # noqa: E501
        """Delete ingest by ID  # noqa: E501

        Delete operation of resource: ingest  # 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_iceberg_ingest_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_iceberg_ingest" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_flow(self, **kwargs):  # noqa: E501
        """Delete flow by ID  # noqa: E501

        Delete operation of resource: flow  # 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_iceberg_ingest_flow(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_flow_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_flow_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_flow_with_http_info(self, **kwargs):  # noqa: E501
        """Delete flow by ID  # noqa: E501

        Delete operation of resource: flow  # 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_iceberg_ingest_flow_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_iceberg_ingest_flow" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_flow_template_by_id(self, name, **kwargs):  # noqa: E501
        """Delete template by ID  # noqa: E501

        Delete operation of resource: template  # 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_iceberg_ingest_flow_template_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_flow_template_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_flow_template_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_flow_template_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete template by ID  # noqa: E501

        Delete operation of resource: template  # 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_iceberg_ingest_flow_template_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_ingest_flow_template_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_ingest_flow_template_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/template/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_native_gpb(self, **kwargs):  # noqa: E501
        """Delete native-gpb by ID  # noqa: E501

        Delete operation of resource: native-gpb  # 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_iceberg_ingest_native_gpb(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_native_gpb_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_native_gpb_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_native_gpb_with_http_info(self, **kwargs):  # noqa: E501
        """Delete native-gpb by ID  # noqa: E501

        Delete operation of resource: native-gpb  # 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_iceberg_ingest_native_gpb_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_iceberg_ingest_native_gpb" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/native-gpb/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings(self, **kwargs):  # noqa: E501
        """Delete ingest-settings by ID  # noqa: E501

        Delete operation of resource: ingest-settings  # 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_iceberg_ingest_settings(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_settings_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_settings_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_settings_with_http_info(self, **kwargs):  # noqa: E501
        """Delete ingest-settings by ID  # noqa: E501

        Delete operation of resource: ingest-settings  # 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_iceberg_ingest_settings_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_iceberg_ingest_settings" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_flow(self, **kwargs):  # noqa: E501
        """Delete flow by ID  # noqa: E501

        Delete operation of resource: flow  # 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_iceberg_ingest_settings_flow(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_settings_flow_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_settings_flow_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_settings_flow_with_http_info(self, **kwargs):  # noqa: E501
        """Delete flow by ID  # noqa: E501

        Delete operation of resource: flow  # 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_iceberg_ingest_settings_flow_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_iceberg_ingest_settings_flow" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_flow_template_by_id(self, name, **kwargs):  # noqa: E501
        """Delete template by ID  # noqa: E501

        Delete operation of resource: template  # 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_iceberg_ingest_settings_flow_template_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_settings_flow_template_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete template by ID  # noqa: E501

        Delete operation of resource: template  # 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_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_ingest_settings_flow_template_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_ingest_settings_flow_template_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/template/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog(self, **kwargs):  # noqa: E501
        """Delete syslog by ID  # noqa: E501

        Delete operation of resource: syslog  # 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_iceberg_ingest_settings_syslog(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_settings_syslog_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_settings_syslog_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_settings_syslog_with_http_info(self, **kwargs):  # noqa: E501
        """Delete syslog by ID  # noqa: E501

        Delete operation of resource: syslog  # 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_iceberg_ingest_settings_syslog_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_iceberg_ingest_settings_syslog" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog_pattern_by_id(self, name, **kwargs):  # noqa: E501
        """Delete pattern by ID  # noqa: E501

        Delete operation of resource: pattern  # 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_iceberg_ingest_settings_syslog_pattern_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete pattern by ID  # noqa: E501

        Delete operation of resource: pattern  # 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_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_ingest_settings_syslog_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_ingest_settings_syslog_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id(self, name, **kwargs):  # noqa: E501
        """Delete pattern-set by ID  # noqa: E501

        Delete operation of resource: pattern-set  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete pattern-set by ID  # noqa: E501

        Delete operation of resource: pattern-set  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_ingest_settings_syslog_pattern_set_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern-set/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog(self, **kwargs):  # noqa: E501
        """Delete syslog by ID  # noqa: E501

        Delete operation of resource: syslog  # 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_iceberg_ingest_syslog(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_syslog_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_syslog_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_syslog_with_http_info(self, **kwargs):  # noqa: E501
        """Delete syslog by ID  # noqa: E501

        Delete operation of resource: syslog  # 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_iceberg_ingest_syslog_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_iceberg_ingest_syslog" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog_pattern_by_id(self, name, **kwargs):  # noqa: E501
        """Delete pattern by ID  # noqa: E501

        Delete operation of resource: pattern  # 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_iceberg_ingest_syslog_pattern_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_syslog_pattern_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete pattern by ID  # noqa: E501

        Delete operation of resource: pattern  # 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_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_ingest_syslog_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_ingest_syslog_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog_pattern_set_by_id(self, name, **kwargs):  # noqa: E501
        """Delete pattern-set by ID  # noqa: E501

        Delete operation of resource: pattern-set  # 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_iceberg_ingest_syslog_pattern_set_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete pattern-set by ID  # noqa: E501

        Delete operation of resource: pattern-set  # 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_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_ingest_syslog_pattern_set_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_ingest_syslog_pattern_set_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern-set/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_data_summarization_raw_by_id(self, name, **kwargs):  # noqa: E501
        """Delete raw-data-summarization by ID  # noqa: E501

        Delete operation of resource: raw data-summarization  # 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_iceberg_profile_data_summarization_raw_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of raw-data-summarization (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_profile_data_summarization_raw_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete raw-data-summarization by ID  # noqa: E501

        Delete operation of resource: raw data-summarization  # 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_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of raw-data-summarization (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_profile_data_summarization_raw_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_profile_data_summarization_raw_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/data-summarization/raw/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_ca_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Delete ca-profile by ID  # noqa: E501

        Delete operation of resource: ca-profile  # 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_iceberg_profile_security_ca_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ca-profile (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_profile_security_ca_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_profile_security_ca_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_profile_security_ca_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete ca-profile by ID  # noqa: E501

        Delete operation of resource: ca-profile  # 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_iceberg_profile_security_ca_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ca-profile (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_profile_security_ca_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_profile_security_ca_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ca-profile/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_local_certificate_by_id(self, name, **kwargs):  # noqa: E501
        """Delete local-certificate by ID  # noqa: E501

        Delete operation of resource: local-certificate  # 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_iceberg_profile_security_local_certificate_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of local-certificate (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_profile_security_local_certificate_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_profile_security_local_certificate_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_profile_security_local_certificate_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete local-certificate by ID  # noqa: E501

        Delete operation of resource: local-certificate  # 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_iceberg_profile_security_local_certificate_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of local-certificate (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token']  # 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_iceberg_profile_security_local_certificate_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_profile_security_local_certificate_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/local-certificate/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_ssh_key_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Delete ssh-key-profile by ID  # noqa: E501

        Delete operation of resource: ssh-key-profile  # 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_iceberg_profile_security_ssh_key_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ssh-key-profile (required)
        :param str authorization: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete ssh-key-profile by ID  # noqa: E501

        Delete operation of resource: ssh-key-profile  # 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_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ssh-key-profile (required)
        :param str authorization: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'authorization']  # 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_iceberg_profile_security_ssh_key_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `delete_iceberg_profile_security_ssh_key_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ssh-key-profile/{name}/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profiles(self, **kwargs):  # noqa: E501
        """Delete profile by ID  # noqa: E501

        Delete entire profile configuration.  # 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_iceberg_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_iceberg_profiles_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_profiles_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """Delete profile by ID  # noqa: E501

        Delete entire profile configuration.  # 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_iceberg_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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_iceberg_profiles" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profiles/', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_dynamic_tagging_by_key(self, key_name, **kwargs):  # noqa: E501
        """Get value of corresponding Dynamic-tagging key  # noqa: E501

        Get Value of corresponding key from dynamic-tagging  # 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_dynamic_tagging_by_key(key_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str key_name: Dynamic-tagging Key (required)
        :param str x_iam_token: authentication header object
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_dynamic_tagging_by_key_with_http_info(key_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_dynamic_tagging_by_key_with_http_info(key_name, **kwargs)  # noqa: E501
            return data

    def get_dynamic_tagging_by_key_with_http_info(self, key_name, **kwargs):  # noqa: E501
        """Get value of corresponding Dynamic-tagging key  # noqa: E501

        Get Value of corresponding key from dynamic-tagging  # 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_dynamic_tagging_by_key_with_http_info(key_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str key_name: Dynamic-tagging Key (required)
        :param str x_iam_token: authentication header object
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['key_name', 'x_iam_token']  # 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_dynamic_tagging_by_key" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'key_name' is set
        if ('key_name' not in params or
                params['key_name'] is None):
            raise ValueError("Missing the required parameter `key_name` when calling `get_dynamic_tagging_by_key`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'key_name' in params:
            query_params.append(('key_name', params['key_name']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/dynamic-tagging/key/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # 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_fields_from_xpath(self, xpath, **kwargs):  # noqa: E501
        """Get last value of all fields before a given timestamp.  # noqa: E501

        Get the values of all fields  # 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_fields_from_xpath(xpath, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str xpath: XPATH (required)
        :param str timestamp: Timestamp
        :return: FieldCaptureSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_fields_from_xpath_with_http_info(xpath, **kwargs)  # noqa: E501
        else:
            (data) = self.get_fields_from_xpath_with_http_info(xpath, **kwargs)  # noqa: E501
            return data

    def get_fields_from_xpath_with_http_info(self, xpath, **kwargs):  # noqa: E501
        """Get last value of all fields before a given timestamp.  # noqa: E501

        Get the values of all fields  # 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_fields_from_xpath_with_http_info(xpath, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str xpath: XPATH (required)
        :param str timestamp: Timestamp
        :return: FieldCaptureSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['xpath', 'timestamp']  # 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_fields_from_xpath" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'xpath' is set
        if ('xpath' not in params or
                params['xpath'] is None):
            raise ValueError("Missing the required parameter `xpath` when calling `get_fields_from_xpath`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'xpath' in params:
            query_params.append(('xpath', params['xpath']))  # noqa: E501
        if 'timestamp' in params:
            query_params.append(('timestamp', params['timestamp']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/field-capture/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FieldCaptureSchema',  # 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 grafana_login(self, **kwargs):  # noqa: E501
        """Login to grafana  # noqa: E501

        Login to Grafana  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.grafana_login(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.grafana_login_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.grafana_login_with_http_info(**kwargs)  # noqa: E501
            return data

    def grafana_login_with_http_info(self, **kwargs):  # noqa: E501
        """Login to grafana  # noqa: E501

        Login to Grafana  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.grafana_login_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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 grafana_login" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/grafana/login/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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 inspect_command_rpc_table_on_device(self, command_rpc_detail, **kwargs):  # noqa: E501
        """Inspect the given iAgent table.  # noqa: E501

        Inspect the given iAgent table on a device and return the results.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.inspect_command_rpc_table_on_device(command_rpc_detail, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CommandRpc command_rpc_detail: command-rpc object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.inspect_command_rpc_table_on_device_with_http_info(command_rpc_detail, **kwargs)  # noqa: E501
        else:
            (data) = self.inspect_command_rpc_table_on_device_with_http_info(command_rpc_detail, **kwargs)  # noqa: E501
            return data

    def inspect_command_rpc_table_on_device_with_http_info(self, command_rpc_detail, **kwargs):  # noqa: E501
        """Inspect the given iAgent table.  # noqa: E501

        Inspect the given iAgent table on a device and return the results.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.inspect_command_rpc_table_on_device_with_http_info(command_rpc_detail, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CommandRpc command_rpc_detail: command-rpc object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['command_rpc_detail', 'x_iam_token']  # 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 inspect_command_rpc_table_on_device" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'command_rpc_detail' is set
        if ('command_rpc_detail' not in params or
                params['command_rpc_detail'] is None):
            raise ValueError("Missing the required parameter `command_rpc_detail` when calling `inspect_command_rpc_table_on_device`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'command_rpc_detail' in params:
            body_params = params['command_rpc_detail']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/inspect/command-rpc/table/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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 restore_grafana(self, restore_file, **kwargs):  # noqa: E501
        """Restore Grafana configuration  # noqa: E501

        Restore Grafana configuration  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_grafana(restore_file, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file restore_file: File content (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_grafana_with_http_info(restore_file, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_grafana_with_http_info(restore_file, **kwargs)  # noqa: E501
            return data

    def restore_grafana_with_http_info(self, restore_file, **kwargs):  # noqa: E501
        """Restore Grafana configuration  # noqa: E501

        Restore Grafana configuration  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_grafana_with_http_info(restore_file, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file restore_file: File content (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['restore_file', 'x_iam_token']  # 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 restore_grafana" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'restore_file' is set
        if ('restore_file' not in params or
                params['restore_file'] is None):
            raise ValueError("Missing the required parameter `restore_file` when calling `restore_grafana`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}
        if 'restore_file' in params:
            local_var_files['restore_file'] = params['restore_file']  # noqa: E501

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/grafana/restore/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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 restore_helper_files(self, restore_file, **kwargs):  # noqa: E501
        """Upload a helper-file.  # noqa: E501

        Upload tar file of helper-files  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_helper_files(restore_file, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file restore_file: File content (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_helper_files_with_http_info(restore_file, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_helper_files_with_http_info(restore_file, **kwargs)  # noqa: E501
            return data

    def restore_helper_files_with_http_info(self, restore_file, **kwargs):  # noqa: E501
        """Upload a helper-file.  # noqa: E501

        Upload tar file of helper-files  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_helper_files_with_http_info(restore_file, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param file restore_file: File content (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['restore_file', 'x_iam_token']  # 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 restore_helper_files" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'restore_file' is set
        if ('restore_file' not in params or
                params['restore_file'] is None):
            raise ValueError("Missing the required parameter `restore_file` when calling `restore_helper_files`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}
        if 'restore_file' in params:
            local_var_files['restore_file'] = params['restore_file']  # noqa: E501

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/helper-files/backup/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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 retrieve_configuration_jobs(self, **kwargs):  # noqa: E501
        """retrieve_configuration_jobs  # noqa: E501

        Return list of all the Commit Job ID's  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_configuration_jobs(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param str job_id: Id of Job
        :param str job_status: Type of job
        :return: list[InlineResponse200]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_configuration_jobs_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_configuration_jobs_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_configuration_jobs_with_http_info(self, **kwargs):  # noqa: E501
        """retrieve_configuration_jobs  # noqa: E501

        Return list of all the Commit Job ID's  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_configuration_jobs_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param str job_id: Id of Job
        :param str job_status: Type of job
        :return: list[InlineResponse200]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'job_id', 'job_status']  # 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 retrieve_configuration_jobs" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'job_id' in params:
            query_params.append(('job_id', params['job_id']))  # noqa: E501
        if 'job_status' in params:
            query_params.append(('job_status', params['job_status']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/configuration/jobs/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[InlineResponse200]',  # 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 retrieve_data_database_table(self, **kwargs):  # noqa: E501
        """Get information about tables for a device of a device-group.  # noqa: E501

        Get information about different types of tables stored for a device of a device-group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_data_database_table(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param str device_id: Name of device
        :param str device_group_name: Name of device-group
        :param str network_group_name: Name of network-group
        :return: list[TableSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_data_database_table_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_data_database_table_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_data_database_table_with_http_info(self, **kwargs):  # noqa: E501
        """Get information about tables for a device of a device-group.  # noqa: E501

        Get information about different types of tables stored for a device of a device-group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_data_database_table_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param str device_id: Name of device
        :param str device_group_name: Name of device-group
        :param str network_group_name: Name of network-group
        :return: list[TableSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'device_id', 'device_group_name', 'network_group_name']  # 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 retrieve_data_database_table" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'device_id' in params:
            query_params.append(('device_id', params['device_id']))  # noqa: E501
        if 'device_group_name' in params:
            query_params.append(('device_group_name', params['device_group_name']))  # noqa: E501
        if 'network_group_name' in params:
            query_params.append(('network_group_name', params['network_group_name']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/data/database/table/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[TableSchema]',  # 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 retrieve_data_database_table_column_by_table_name(self, table_name, **kwargs):  # noqa: E501
        """Get information about columns in a table.  # noqa: E501

        Get information about columns in a table.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_data_database_table_column_by_table_name(table_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str table_name: Name of table (required)
        :param str x_iam_token: authentication header object
        :param str device_id: Name of device
        :param str device_group_name: Name of device-group
        :param str network_group_name: Name of network-group
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_data_database_table_column_by_table_name_with_http_info(table_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_data_database_table_column_by_table_name_with_http_info(table_name, **kwargs)  # noqa: E501
            return data

    def retrieve_data_database_table_column_by_table_name_with_http_info(self, table_name, **kwargs):  # noqa: E501
        """Get information about columns in a table.  # noqa: E501

        Get information about columns in a table.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_data_database_table_column_by_table_name_with_http_info(table_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str table_name: Name of table (required)
        :param str x_iam_token: authentication header object
        :param str device_id: Name of device
        :param str device_group_name: Name of device-group
        :param str network_group_name: Name of network-group
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['table_name', 'x_iam_token', 'device_id', 'device_group_name', 'network_group_name']  # 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 retrieve_data_database_table_column_by_table_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'table_name' is set
        if ('table_name' not in params or
                params['table_name'] is None):
            raise ValueError("Missing the required parameter `table_name` when calling `retrieve_data_database_table_column_by_table_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'device_id' in params:
            query_params.append(('device_id', params['device_id']))  # noqa: E501
        if 'device_group_name' in params:
            query_params.append(('device_group_name', params['device_group_name']))  # noqa: E501
        if 'network_group_name' in params:
            query_params.append(('network_group_name', params['network_group_name']))  # noqa: E501
        if 'table_name' in params:
            query_params.append(('table_name', params['table_name']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/data/database/table/column/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_data_database_tags_by_table_name(self, table_name, **kwargs):  # noqa: E501
        """Get information about tags keys and values in a table.  # noqa: E501

        Get information about tags keys and values in a table.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_data_database_tags_by_table_name(table_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str table_name: Name of table (required)
        :param str x_iam_token: authentication header object
        :param str device_id: Name of device
        :param str device_group_name: Name of device-group
        :param str network_group_name: Name of network-group
        :param str tag: Tag key for which values are requested.
        :param str where_clause: Where condition to select values for the requested key. This would not be processed if there is no `tag` query parameter. eg: `tag_key1=val1 AND tag_key2=val2`
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_data_database_tags_by_table_name_with_http_info(table_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_data_database_tags_by_table_name_with_http_info(table_name, **kwargs)  # noqa: E501
            return data

    def retrieve_data_database_tags_by_table_name_with_http_info(self, table_name, **kwargs):  # noqa: E501
        """Get information about tags keys and values in a table.  # noqa: E501

        Get information about tags keys and values in a table.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_data_database_tags_by_table_name_with_http_info(table_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str table_name: Name of table (required)
        :param str x_iam_token: authentication header object
        :param str device_id: Name of device
        :param str device_group_name: Name of device-group
        :param str network_group_name: Name of network-group
        :param str tag: Tag key for which values are requested.
        :param str where_clause: Where condition to select values for the requested key. This would not be processed if there is no `tag` query parameter. eg: `tag_key1=val1 AND tag_key2=val2`
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['table_name', 'x_iam_token', 'device_id', 'device_group_name', 'network_group_name', 'tag', 'where_clause']  # 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 retrieve_data_database_tags_by_table_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'table_name' is set
        if ('table_name' not in params or
                params['table_name'] is None):
            raise ValueError("Missing the required parameter `table_name` when calling `retrieve_data_database_tags_by_table_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'device_id' in params:
            query_params.append(('device_id', params['device_id']))  # noqa: E501
        if 'device_group_name' in params:
            query_params.append(('device_group_name', params['device_group_name']))  # noqa: E501
        if 'network_group_name' in params:
            query_params.append(('network_group_name', params['network_group_name']))  # noqa: E501
        if 'table_name' in params:
            query_params.append(('table_name', params['table_name']))  # noqa: E501
        if 'tag' in params:
            query_params.append(('tag', params['tag']))  # noqa: E501
        if 'where_clause' in params:
            query_params.append(('where_clause', params['where_clause']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/data/database/table/tags/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_debug_jobs(self, **kwargs):  # noqa: E501
        """retrieve_debug_jobs  # noqa: E501

        Return the status of the last \"/debug/\" job   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_debug_jobs(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param str job_id: Id of Job
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_debug_jobs_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_debug_jobs_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_debug_jobs_with_http_info(self, **kwargs):  # noqa: E501
        """retrieve_debug_jobs  # noqa: E501

        Return the status of the last \"/debug/\" job   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_debug_jobs_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param str job_id: Id of Job
        :return: object
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'job_id']  # 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 retrieve_debug_jobs" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'job_id' in params:
            query_params.append(('job_id', params['job_id']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/debug/jobs/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='object',  # 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 retrieve_event(self, from_timestamp, device_id, **kwargs):  # noqa: E501
        """Get all events for a device.  # noqa: E501

        Get the list of events for a device. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event(from_timestamp, device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime from_timestamp: Starting timestamp (required)
        :param str device_id: device-id of the device for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str device_group_name: Device group's device-group-name of which the device is part
        :param str granularity: Granularity of query
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_event_with_http_info(from_timestamp, device_id, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_event_with_http_info(from_timestamp, device_id, **kwargs)  # noqa: E501
            return data

    def retrieve_event_with_http_info(self, from_timestamp, device_id, **kwargs):  # noqa: E501
        """Get all events for a device.  # noqa: E501

        Get the list of events for a device. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_with_http_info(from_timestamp, device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime from_timestamp: Starting timestamp (required)
        :param str device_id: device-id of the device for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str device_group_name: Device group's device-group-name of which the device is part
        :param str granularity: Granularity of query
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['from_timestamp', 'device_id', 'x_iam_token', 'to_timestamp', 'device_group_name', 'granularity', 'color']  # 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 retrieve_event" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'from_timestamp' is set
        if ('from_timestamp' not in params or
                params['from_timestamp'] is None):
            raise ValueError("Missing the required parameter `from_timestamp` when calling `retrieve_event`")  # noqa: E501
        # verify the required parameter 'device_id' is set
        if ('device_id' not in params or
                params['device_id'] is None):
            raise ValueError("Missing the required parameter `device_id` when calling `retrieve_event`")  # noqa: E501

        if 'granularity' in params and not re.search(r'^[0-9]*[\'ns\' | \'u\' | \'µ\' | \'ms\' | \'s\' | \'m\' | \'h\' | \'d\' | \'w\']$', params['granularity']):  # noqa: E501
            raise ValueError("Invalid value for parameter `granularity` when calling `retrieve_event`, must conform to the pattern `/^[0-9]*['ns' | 'u' | 'µ' | 'ms' | 's' | 'm' | 'h' | 'd' | 'w']$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'from_timestamp' in params:
            query_params.append(('from_timestamp', params['from_timestamp']))  # noqa: E501
        if 'to_timestamp' in params:
            query_params.append(('to_timestamp', params['to_timestamp']))  # noqa: E501
        if 'device_id' in params:
            query_params.append(('device_id', params['device_id']))  # noqa: E501
        if 'device_group_name' in params:
            query_params.append(('device_group_name', params['device_group_name']))  # noqa: E501
        if 'granularity' in params:
            query_params.append(('granularity', params['granularity']))  # noqa: E501
        if 'color' in params:
            query_params.append(('color', params['color']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/event/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Event]',  # 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 retrieve_event_by_event_name(self, event_name, from_timestamp, device_id, **kwargs):  # noqa: E501
        """Get instances of a device event.  # noqa: E501

        Get instances of a specified device event. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_by_event_name(event_name, from_timestamp, device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str event_name: Name of event (required)
        :param datetime from_timestamp: Starting timestamp (required)
        :param str device_id: device-id of the device for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str device_group_name: device-group-name of which the device is part
        :param str granularity: Granularity of query
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_event_by_event_name_with_http_info(event_name, from_timestamp, device_id, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_event_by_event_name_with_http_info(event_name, from_timestamp, device_id, **kwargs)  # noqa: E501
            return data

    def retrieve_event_by_event_name_with_http_info(self, event_name, from_timestamp, device_id, **kwargs):  # noqa: E501
        """Get instances of a device event.  # noqa: E501

        Get instances of a specified device event. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_by_event_name_with_http_info(event_name, from_timestamp, device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str event_name: Name of event (required)
        :param datetime from_timestamp: Starting timestamp (required)
        :param str device_id: device-id of the device for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str device_group_name: device-group-name of which the device is part
        :param str granularity: Granularity of query
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['event_name', 'from_timestamp', 'device_id', 'x_iam_token', 'to_timestamp', 'device_group_name', 'granularity', 'color']  # 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 retrieve_event_by_event_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'event_name' is set
        if ('event_name' not in params or
                params['event_name'] is None):
            raise ValueError("Missing the required parameter `event_name` when calling `retrieve_event_by_event_name`")  # noqa: E501
        # verify the required parameter 'from_timestamp' is set
        if ('from_timestamp' not in params or
                params['from_timestamp'] is None):
            raise ValueError("Missing the required parameter `from_timestamp` when calling `retrieve_event_by_event_name`")  # noqa: E501
        # verify the required parameter 'device_id' is set
        if ('device_id' not in params or
                params['device_id'] is None):
            raise ValueError("Missing the required parameter `device_id` when calling `retrieve_event_by_event_name`")  # noqa: E501

        if 'granularity' in params and not re.search(r'^[0-9]*[\'ns\' | \'u\' | \'µ\' | \'ms\' | \'s\' | \'m\' | \'h\' | \'d\' | \'w\']$', params['granularity']):  # noqa: E501
            raise ValueError("Invalid value for parameter `granularity` when calling `retrieve_event_by_event_name`, must conform to the pattern `/^[0-9]*['ns' | 'u' | 'µ' | 'ms' | 's' | 'm' | 'h' | 'd' | 'w']$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'event_name' in params:
            path_params['event_name'] = params['event_name']  # noqa: E501

        query_params = []
        if 'from_timestamp' in params:
            query_params.append(('from_timestamp', params['from_timestamp']))  # noqa: E501
        if 'to_timestamp' in params:
            query_params.append(('to_timestamp', params['to_timestamp']))  # noqa: E501
        if 'device_id' in params:
            query_params.append(('device_id', params['device_id']))  # noqa: E501
        if 'device_group_name' in params:
            query_params.append(('device_group_name', params['device_group_name']))  # noqa: E501
        if 'granularity' in params:
            query_params.append(('granularity', params['granularity']))  # noqa: E501
        if 'color' in params:
            query_params.append(('color', params['color']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/event/{event_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Event]',  # 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 retrieve_event_by_event_name_device_group(self, event_name, from_timestamp, device_group_name, **kwargs):  # noqa: E501
        """Get instances of a device-group event.  # noqa: E501

        Get instances of a specified device-group event. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_by_event_name_device_group(event_name, from_timestamp, device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str event_name: Name of event (required)
        :param datetime from_timestamp: Starting timestamp (required)
        :param str device_group_name: device_group_name of the device-group for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str granularity: Granularity of query
        :param list[str] device_id: list of devices under a device-group to be fetched
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_event_by_event_name_device_group_with_http_info(event_name, from_timestamp, device_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_event_by_event_name_device_group_with_http_info(event_name, from_timestamp, device_group_name, **kwargs)  # noqa: E501
            return data

    def retrieve_event_by_event_name_device_group_with_http_info(self, event_name, from_timestamp, device_group_name, **kwargs):  # noqa: E501
        """Get instances of a device-group event.  # noqa: E501

        Get instances of a specified device-group event. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_by_event_name_device_group_with_http_info(event_name, from_timestamp, device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str event_name: Name of event (required)
        :param datetime from_timestamp: Starting timestamp (required)
        :param str device_group_name: device_group_name of the device-group for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str granularity: Granularity of query
        :param list[str] device_id: list of devices under a device-group to be fetched
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['event_name', 'from_timestamp', 'device_group_name', 'x_iam_token', 'to_timestamp', 'granularity', 'device_id', 'color']  # 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 retrieve_event_by_event_name_device_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'event_name' is set
        if ('event_name' not in params or
                params['event_name'] is None):
            raise ValueError("Missing the required parameter `event_name` when calling `retrieve_event_by_event_name_device_group`")  # noqa: E501
        # verify the required parameter 'from_timestamp' is set
        if ('from_timestamp' not in params or
                params['from_timestamp'] is None):
            raise ValueError("Missing the required parameter `from_timestamp` when calling `retrieve_event_by_event_name_device_group`")  # noqa: E501
        # verify the required parameter 'device_group_name' is set
        if ('device_group_name' not in params or
                params['device_group_name'] is None):
            raise ValueError("Missing the required parameter `device_group_name` when calling `retrieve_event_by_event_name_device_group`")  # noqa: E501

        if 'granularity' in params and not re.search(r'^[0-9]*[\'ns\' | \'u\' | \'µ\' | \'ms\' | \'s\' | \'m\' | \'h\' | \'d\' | \'w\']$', params['granularity']):  # noqa: E501
            raise ValueError("Invalid value for parameter `granularity` when calling `retrieve_event_by_event_name_device_group`, must conform to the pattern `/^[0-9]*['ns' | 'u' | 'µ' | 'ms' | 's' | 'm' | 'h' | 'd' | 'w']$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'event_name' in params:
            path_params['event_name'] = params['event_name']  # noqa: E501

        query_params = []
        if 'from_timestamp' in params:
            query_params.append(('from_timestamp', params['from_timestamp']))  # noqa: E501
        if 'to_timestamp' in params:
            query_params.append(('to_timestamp', params['to_timestamp']))  # noqa: E501
        if 'device_group_name' in params:
            query_params.append(('device_group_name', params['device_group_name']))  # noqa: E501
        if 'granularity' in params:
            query_params.append(('granularity', params['granularity']))  # noqa: E501
        if 'device_id' in params:
            query_params.append(('device_id', params['device_id']))  # noqa: E501
            collection_formats['device_id'] = 'csv'  # noqa: E501
        if 'color' in params:
            query_params.append(('color', params['color']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/event/device-group/{event_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Event]',  # 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 retrieve_event_by_event_name_network_group(self, event_name, from_timestamp, network_group_name, **kwargs):  # noqa: E501
        """Get instances of a network-group event.  # noqa: E501

        Get instances of a specified network-group event. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_by_event_name_network_group(event_name, from_timestamp, network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str event_name: Name of event (required)
        :param datetime from_timestamp: Starting timestamp (required)
        :param str network_group_name: network_group_name of the network-group for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str granularity: Granularity of query
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_event_by_event_name_network_group_with_http_info(event_name, from_timestamp, network_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_event_by_event_name_network_group_with_http_info(event_name, from_timestamp, network_group_name, **kwargs)  # noqa: E501
            return data

    def retrieve_event_by_event_name_network_group_with_http_info(self, event_name, from_timestamp, network_group_name, **kwargs):  # noqa: E501
        """Get instances of a network-group event.  # noqa: E501

        Get instances of a specified network-group event. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_by_event_name_network_group_with_http_info(event_name, from_timestamp, network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str event_name: Name of event (required)
        :param datetime from_timestamp: Starting timestamp (required)
        :param str network_group_name: network_group_name of the network-group for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str granularity: Granularity of query
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['event_name', 'from_timestamp', 'network_group_name', 'x_iam_token', 'to_timestamp', 'granularity', 'color']  # 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 retrieve_event_by_event_name_network_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'event_name' is set
        if ('event_name' not in params or
                params['event_name'] is None):
            raise ValueError("Missing the required parameter `event_name` when calling `retrieve_event_by_event_name_network_group`")  # noqa: E501
        # verify the required parameter 'from_timestamp' is set
        if ('from_timestamp' not in params or
                params['from_timestamp'] is None):
            raise ValueError("Missing the required parameter `from_timestamp` when calling `retrieve_event_by_event_name_network_group`")  # noqa: E501
        # verify the required parameter 'network_group_name' is set
        if ('network_group_name' not in params or
                params['network_group_name'] is None):
            raise ValueError("Missing the required parameter `network_group_name` when calling `retrieve_event_by_event_name_network_group`")  # noqa: E501

        if 'granularity' in params and not re.search(r'^[0-9]*[\'ns\' | \'u\' | \'µ\' | \'ms\' | \'s\' | \'m\' | \'h\' | \'d\' | \'w\']$', params['granularity']):  # noqa: E501
            raise ValueError("Invalid value for parameter `granularity` when calling `retrieve_event_by_event_name_network_group`, must conform to the pattern `/^[0-9]*['ns' | 'u' | 'µ' | 'ms' | 's' | 'm' | 'h' | 'd' | 'w']$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'event_name' in params:
            path_params['event_name'] = params['event_name']  # noqa: E501

        query_params = []
        if 'from_timestamp' in params:
            query_params.append(('from_timestamp', params['from_timestamp']))  # noqa: E501
        if 'to_timestamp' in params:
            query_params.append(('to_timestamp', params['to_timestamp']))  # noqa: E501
        if 'network_group_name' in params:
            query_params.append(('network_group_name', params['network_group_name']))  # noqa: E501
        if 'granularity' in params:
            query_params.append(('granularity', params['granularity']))  # noqa: E501
        if 'color' in params:
            query_params.append(('color', params['color']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/event/network-group/{event_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Event]',  # 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 retrieve_event_device_group(self, from_timestamp, device_group_name, **kwargs):  # noqa: E501
        """Get all events for a device-group.  # noqa: E501

        Get the list of events for a device-group. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_device_group(from_timestamp, device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime from_timestamp: Starting timestamp (required)
        :param str device_group_name: device_group_name of the device-group for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str granularity: Granularity of query
        :param list[str] device_id: list of devices under a device-group to be fetched
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_event_device_group_with_http_info(from_timestamp, device_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_event_device_group_with_http_info(from_timestamp, device_group_name, **kwargs)  # noqa: E501
            return data

    def retrieve_event_device_group_with_http_info(self, from_timestamp, device_group_name, **kwargs):  # noqa: E501
        """Get all events for a device-group.  # noqa: E501

        Get the list of events for a device-group. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_device_group_with_http_info(from_timestamp, device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime from_timestamp: Starting timestamp (required)
        :param str device_group_name: device_group_name of the device-group for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str granularity: Granularity of query
        :param list[str] device_id: list of devices under a device-group to be fetched
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['from_timestamp', 'device_group_name', 'x_iam_token', 'to_timestamp', 'granularity', 'device_id', 'color']  # 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 retrieve_event_device_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'from_timestamp' is set
        if ('from_timestamp' not in params or
                params['from_timestamp'] is None):
            raise ValueError("Missing the required parameter `from_timestamp` when calling `retrieve_event_device_group`")  # noqa: E501
        # verify the required parameter 'device_group_name' is set
        if ('device_group_name' not in params or
                params['device_group_name'] is None):
            raise ValueError("Missing the required parameter `device_group_name` when calling `retrieve_event_device_group`")  # noqa: E501

        if 'granularity' in params and not re.search(r'^[0-9]*[\'ns\' | \'u\' | \'µ\' | \'ms\' | \'s\' | \'m\' | \'h\' | \'d\' | \'w\']$', params['granularity']):  # noqa: E501
            raise ValueError("Invalid value for parameter `granularity` when calling `retrieve_event_device_group`, must conform to the pattern `/^[0-9]*['ns' | 'u' | 'µ' | 'ms' | 's' | 'm' | 'h' | 'd' | 'w']$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'from_timestamp' in params:
            query_params.append(('from_timestamp', params['from_timestamp']))  # noqa: E501
        if 'to_timestamp' in params:
            query_params.append(('to_timestamp', params['to_timestamp']))  # noqa: E501
        if 'device_group_name' in params:
            query_params.append(('device_group_name', params['device_group_name']))  # noqa: E501
        if 'granularity' in params:
            query_params.append(('granularity', params['granularity']))  # noqa: E501
        if 'device_id' in params:
            query_params.append(('device_id', params['device_id']))  # noqa: E501
            collection_formats['device_id'] = 'csv'  # noqa: E501
        if 'color' in params:
            query_params.append(('color', params['color']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/event/device-group/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Event]',  # 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 retrieve_event_network_group(self, from_timestamp, network_group_name, **kwargs):  # noqa: E501
        """Get all events for a network-group.  # noqa: E501

        Get the list of events for a network-group. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_network_group(from_timestamp, network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime from_timestamp: Starting timestamp (required)
        :param str network_group_name: network_group_name of the network-group for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str granularity: Granularity of query
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_event_network_group_with_http_info(from_timestamp, network_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_event_network_group_with_http_info(from_timestamp, network_group_name, **kwargs)  # noqa: E501
            return data

    def retrieve_event_network_group_with_http_info(self, from_timestamp, network_group_name, **kwargs):  # noqa: E501
        """Get all events for a network-group.  # noqa: E501

        Get the list of events for a network-group. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_event_network_group_with_http_info(from_timestamp, network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime from_timestamp: Starting timestamp (required)
        :param str network_group_name: network_group_name of the network-group for which events are requested (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str granularity: Granularity of query
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['from_timestamp', 'network_group_name', 'x_iam_token', 'to_timestamp', 'granularity', 'color']  # 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 retrieve_event_network_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'from_timestamp' is set
        if ('from_timestamp' not in params or
                params['from_timestamp'] is None):
            raise ValueError("Missing the required parameter `from_timestamp` when calling `retrieve_event_network_group`")  # noqa: E501
        # verify the required parameter 'network_group_name' is set
        if ('network_group_name' not in params or
                params['network_group_name'] is None):
            raise ValueError("Missing the required parameter `network_group_name` when calling `retrieve_event_network_group`")  # noqa: E501

        if 'granularity' in params and not re.search(r'^[0-9]*[\'ns\' | \'u\' | \'µ\' | \'ms\' | \'s\' | \'m\' | \'h\' | \'d\' | \'w\']$', params['granularity']):  # noqa: E501
            raise ValueError("Invalid value for parameter `granularity` when calling `retrieve_event_network_group`, must conform to the pattern `/^[0-9]*['ns' | 'u' | 'µ' | 'ms' | 's' | 'm' | 'h' | 'd' | 'w']$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'from_timestamp' in params:
            query_params.append(('from_timestamp', params['from_timestamp']))  # noqa: E501
        if 'to_timestamp' in params:
            query_params.append(('to_timestamp', params['to_timestamp']))  # noqa: E501
        if 'network_group_name' in params:
            query_params.append(('network_group_name', params['network_group_name']))  # noqa: E501
        if 'granularity' in params:
            query_params.append(('granularity', params['granularity']))  # noqa: E501
        if 'color' in params:
            query_params.append(('color', params['color']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/event/network-group/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Event]',  # 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 retrieve_events(self, from_timestamp, **kwargs):  # noqa: E501
        """Get all events.  # noqa: E501

        Get the list of all events. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_events(from_timestamp, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime from_timestamp: Starting timestamp (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_events_with_http_info(from_timestamp, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_events_with_http_info(from_timestamp, **kwargs)  # noqa: E501
            return data

    def retrieve_events_with_http_info(self, from_timestamp, **kwargs):  # noqa: E501
        """Get all events.  # noqa: E501

        Get the list of all events. Filtering is possible with the use of various query parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_events_with_http_info(from_timestamp, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param datetime from_timestamp: Starting timestamp (required)
        :param str x_iam_token: authentication header object
        :param datetime to_timestamp: Ending timestamp
        :param str color: Color of events.
        :return: list[Event]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['from_timestamp', 'x_iam_token', 'to_timestamp', 'color']  # 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 retrieve_events" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'from_timestamp' is set
        if ('from_timestamp' not in params or
                params['from_timestamp'] is None):
            raise ValueError("Missing the required parameter `from_timestamp` when calling `retrieve_events`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'from_timestamp' in params:
            query_params.append(('from_timestamp', params['from_timestamp']))  # noqa: E501
        if 'to_timestamp' in params:
            query_params.append(('to_timestamp', params['to_timestamp']))  # noqa: E501
        if 'color' in params:
            query_params.append(('color', params['color']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/events/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Event]',  # 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 retrieve_files_certificates_by_file_name(self, file_name, **kwargs):  # noqa: E501
        """Download a certificate-file.  # noqa: E501

        Download the specified certificate-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.retrieve_files_certificates_by_file_name(file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :param str certificate_type: Certificate type
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_files_certificates_by_file_name_with_http_info(file_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_files_certificates_by_file_name_with_http_info(file_name, **kwargs)  # noqa: E501
            return data

    def retrieve_files_certificates_by_file_name_with_http_info(self, file_name, **kwargs):  # noqa: E501
        """Download a certificate-file.  # noqa: E501

        Download the specified certificate-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.retrieve_files_certificates_by_file_name_with_http_info(file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :param str certificate_type: Certificate type
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['file_name', 'x_iam_token', 'input_path', 'certificate_type']  # 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 retrieve_files_certificates_by_file_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'file_name' is set
        if ('file_name' not in params or
                params['file_name'] is None):
            raise ValueError("Missing the required parameter `file_name` when calling `retrieve_files_certificates_by_file_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'file_name' in params:
            path_params['file_name'] = params['file_name']  # noqa: E501

        query_params = []
        if 'input_path' in params:
            query_params.append(('input_path', params['input_path']))  # noqa: E501
        if 'certificate_type' in params:
            query_params.append(('certificate_type', params['certificate_type']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/octet-stream', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/certificates/{file_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='file',  # 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 retrieve_files_helper_files(self, **kwargs):  # noqa: E501
        """Get all helper-file names.  # noqa: E501

        Get a list of all the helper-file file-names.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_files_helper_files(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_files_helper_files_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_files_helper_files_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_files_helper_files_with_http_info(self, **kwargs):  # noqa: E501
        """Get all helper-file names.  # noqa: E501

        Get a list of all the helper-file file-names.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_files_helper_files_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'input_path']  # 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 retrieve_files_helper_files" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'input_path' in params:
            query_params.append(('input_path', params['input_path']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/helper-files/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_files_helper_files_by_file_name(self, file_name, **kwargs):  # noqa: E501
        """Download a helper-file.  # noqa: E501

        Download the specified helper-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.retrieve_files_helper_files_by_file_name(file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_files_helper_files_by_file_name_with_http_info(file_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_files_helper_files_by_file_name_with_http_info(file_name, **kwargs)  # noqa: E501
            return data

    def retrieve_files_helper_files_by_file_name_with_http_info(self, file_name, **kwargs):  # noqa: E501
        """Download a helper-file.  # noqa: E501

        Download the specified helper-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.retrieve_files_helper_files_by_file_name_with_http_info(file_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str file_name: File name (required)
        :param str x_iam_token: authentication header object
        :param str input_path: Input path
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['file_name', 'x_iam_token', 'input_path']  # 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 retrieve_files_helper_files_by_file_name" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'file_name' is set
        if ('file_name' not in params or
                params['file_name'] is None):
            raise ValueError("Missing the required parameter `file_name` when calling `retrieve_files_helper_files_by_file_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'file_name' in params:
            path_params['file_name'] = params['file_name']  # noqa: E501

        query_params = []
        if 'input_path' in params:
            query_params.append(('input_path', params['input_path']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/octet-stream', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/files/helper-files/{file_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='file',  # 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 retrieve_health_all(self, **kwargs):  # noqa: E501
        """Return a dict with health of devices in device groups and network groups  # noqa: E501

        Returns health of network-groups and devices in device-groups  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_health_all(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: HealthSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_health_all_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_health_all_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_health_all_with_http_info(self, **kwargs):  # noqa: E501
        """Return a dict with health of devices in device groups and network groups  # noqa: E501

        Returns health of network-groups and devices in device-groups  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_health_all_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: HealthSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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 retrieve_health_all" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/health/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='HealthSchema',  # 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 retrieve_health_tree_by_device_group(self, device_group_name, **kwargs):  # noqa: E501
        """Get device-group health-tree.  # noqa: E501

        Get health-tree of a specified device-group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_health_tree_by_device_group(device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: `device-group-name` of device-group (required)
        :param str x_iam_token: authentication header object
        :param datetime timestamp: Timestamp at which health tree is requested. If not specified, current server timestamp is used.
        :param int tolerance: Timestamp tolerance in seconds. With this option, health-tree will contain latest data between `timestamp-2*tolerance` and `timestamp`. Default value is `2*frequency` where `frequency` is extracted from `trigger`.
        :param list[str] device: list of devices under a device-group to be fetched
        :return: DeviceGroupHealthTree
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_health_tree_by_device_group_with_http_info(device_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_health_tree_by_device_group_with_http_info(device_group_name, **kwargs)  # noqa: E501
            return data

    def retrieve_health_tree_by_device_group_with_http_info(self, device_group_name, **kwargs):  # noqa: E501
        """Get device-group health-tree.  # noqa: E501

        Get health-tree of a specified device-group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_health_tree_by_device_group_with_http_info(device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: `device-group-name` of device-group (required)
        :param str x_iam_token: authentication header object
        :param datetime timestamp: Timestamp at which health tree is requested. If not specified, current server timestamp is used.
        :param int tolerance: Timestamp tolerance in seconds. With this option, health-tree will contain latest data between `timestamp-2*tolerance` and `timestamp`. Default value is `2*frequency` where `frequency` is extracted from `trigger`.
        :param list[str] device: list of devices under a device-group to be fetched
        :return: DeviceGroupHealthTree
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['device_group_name', 'x_iam_token', 'timestamp', 'tolerance', 'device']  # 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 retrieve_health_tree_by_device_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'device_group_name' is set
        if ('device_group_name' not in params or
                params['device_group_name'] is None):
            raise ValueError("Missing the required parameter `device_group_name` when calling `retrieve_health_tree_by_device_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'device_group_name' in params:
            path_params['device_group_name'] = params['device_group_name']  # noqa: E501

        query_params = []
        if 'timestamp' in params:
            query_params.append(('timestamp', params['timestamp']))  # noqa: E501
        if 'tolerance' in params:
            query_params.append(('tolerance', params['tolerance']))  # noqa: E501
        if 'device' in params:
            query_params.append(('device', params['device']))  # noqa: E501
            collection_formats['device'] = 'csv'  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/health-tree/device-group/{device_group_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeviceGroupHealthTree',  # 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 retrieve_health_tree_by_id(self, device_id, **kwargs):  # noqa: E501
        """Return a device's health-tree.  # noqa: E501

        Return health-tree of a specified device identified by `device-id`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_health_tree_by_id(device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_id: `device-id` of device (required)
        :param str x_iam_token: authentication header object
        :param datetime timestamp: Timestamp at which health tree is requested. If not specified, current server timestamp is used.
        :param int tolerance: Timestamp tolerance in seconds. With this option, health-tree will contain latest data between `timestamp-2*tolerance` and `timestamp`. Default value is `2*frequency` where `frequency` is extracted from `trigger`.
        :return: DeviceHealthTree
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_health_tree_by_id_with_http_info(device_id, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_health_tree_by_id_with_http_info(device_id, **kwargs)  # noqa: E501
            return data

    def retrieve_health_tree_by_id_with_http_info(self, device_id, **kwargs):  # noqa: E501
        """Return a device's health-tree.  # noqa: E501

        Return health-tree of a specified device identified by `device-id`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_health_tree_by_id_with_http_info(device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_id: `device-id` of device (required)
        :param str x_iam_token: authentication header object
        :param datetime timestamp: Timestamp at which health tree is requested. If not specified, current server timestamp is used.
        :param int tolerance: Timestamp tolerance in seconds. With this option, health-tree will contain latest data between `timestamp-2*tolerance` and `timestamp`. Default value is `2*frequency` where `frequency` is extracted from `trigger`.
        :return: DeviceHealthTree
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['device_id', 'x_iam_token', 'timestamp', 'tolerance']  # 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 retrieve_health_tree_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'device_id' is set
        if ('device_id' not in params or
                params['device_id'] is None):
            raise ValueError("Missing the required parameter `device_id` when calling `retrieve_health_tree_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'device_id' in params:
            path_params['device_id'] = params['device_id']  # noqa: E501

        query_params = []
        if 'timestamp' in params:
            query_params.append(('timestamp', params['timestamp']))  # noqa: E501
        if 'tolerance' in params:
            query_params.append(('tolerance', params['tolerance']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/health-tree/{device_id}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeviceHealthTree',  # 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 retrieve_health_tree_by_network_group(self, network_group_name, **kwargs):  # noqa: E501
        """Get network-group health-tree.  # noqa: E501

        Get health-tree of a specified network-group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_health_tree_by_network_group(network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: `network-group-name` of network-group (required)
        :param str x_iam_token: authentication header object
        :param datetime timestamp: Timestamp at which health tree is requested. If not specified, current server timestamp is used.
        :param int tolerance: Timestamp tolerance in seconds. With this option, health-tree will contain latest data between `timestamp-2*tolerance` and `timestamp`. Default value is `2*frequency` where `frequency` is extracted from `trigger`.
        :return: NetworkHealthTree
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_health_tree_by_network_group_with_http_info(network_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_health_tree_by_network_group_with_http_info(network_group_name, **kwargs)  # noqa: E501
            return data

    def retrieve_health_tree_by_network_group_with_http_info(self, network_group_name, **kwargs):  # noqa: E501
        """Get network-group health-tree.  # noqa: E501

        Get health-tree of a specified network-group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_health_tree_by_network_group_with_http_info(network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: `network-group-name` of network-group (required)
        :param str x_iam_token: authentication header object
        :param datetime timestamp: Timestamp at which health tree is requested. If not specified, current server timestamp is used.
        :param int tolerance: Timestamp tolerance in seconds. With this option, health-tree will contain latest data between `timestamp-2*tolerance` and `timestamp`. Default value is `2*frequency` where `frequency` is extracted from `trigger`.
        :return: NetworkHealthTree
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['network_group_name', 'x_iam_token', 'timestamp', 'tolerance']  # 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 retrieve_health_tree_by_network_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'network_group_name' is set
        if ('network_group_name' not in params or
                params['network_group_name'] is None):
            raise ValueError("Missing the required parameter `network_group_name` when calling `retrieve_health_tree_by_network_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'network_group_name' in params:
            path_params['network_group_name'] = params['network_group_name']  # noqa: E501

        query_params = []
        if 'timestamp' in params:
            query_params.append(('timestamp', params['timestamp']))  # noqa: E501
        if 'tolerance' in params:
            query_params.append(('tolerance', params['tolerance']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/health-tree/network-group/{network_group_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NetworkHealthTree',  # 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 retrieve_healthbot_deployment_deployment(self, **kwargs):  # noqa: E501
        """Retrieve deployment  # noqa: E501

        Retrieve operation of resource: deployment  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_deployment_deployment(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: DeploymentSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_deployment_deployment_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_deployment_deployment_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_deployment_deployment_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve deployment  # noqa: E501

        Retrieve operation of resource: deployment  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_deployment_deployment_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: DeploymentSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_deployment_deployment" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/deployment/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeploymentSchema',  # 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 retrieve_healthbot_device_details_by_uuids(self, uuid_object, **kwargs):  # noqa: E501
        """Get device-identifying details by for specified UUIDs.  # noqa: E501

        Get device-identifying details (device-id and TSDB databases if playbooks are deployed on it) for all the UUIDs present in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_device_details_by_uuids(uuid_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UuidObject uuid_object: device_uuids object (required)
        :param str x_iam_token: authentication header object
        :return: DeviceDetailsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_device_details_by_uuids_with_http_info(uuid_object, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_device_details_by_uuids_with_http_info(uuid_object, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_device_details_by_uuids_with_http_info(self, uuid_object, **kwargs):  # noqa: E501
        """Get device-identifying details by for specified UUIDs.  # noqa: E501

        Get device-identifying details (device-id and TSDB databases if playbooks are deployed on it) for all the UUIDs present in the request body.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_device_details_by_uuids_with_http_info(uuid_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UuidObject uuid_object: device_uuids object (required)
        :param str x_iam_token: authentication header object
        :return: DeviceDetailsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['uuid_object', 'x_iam_token']  # 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 retrieve_healthbot_device_details_by_uuids" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'uuid_object' is set
        if ('uuid_object' not in params or
                params['uuid_object'] is None):
            raise ValueError("Missing the required parameter `uuid_object` when calling `retrieve_healthbot_device_details_by_uuids`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'uuid_object' in params:
            body_params = params['uuid_object']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/deployed-device-details/', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeviceDetailsSchema',  # 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 retrieve_healthbot_dynamic_tagging(self, **kwargs):  # noqa: E501
        """Retrieve dynamic-tagging by ID  # noqa: E501

        Retrieve operation of resource: dynamic-tagging  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_dynamic_tagging(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_dynamic_tagging_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_dynamic_tagging_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_dynamic_tagging_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve dynamic-tagging by ID  # noqa: E501

        Retrieve operation of resource: dynamic-tagging  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_dynamic_tagging_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token']  # 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 retrieve_healthbot_dynamic_tagging" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/dynamic-tagging/keys/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_byoi_custom_plugin_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve custom-plugin by ID  # noqa: E501

        Retrieve operation of resource: custom-plugin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_custom_plugin_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CustomPluginSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve custom-plugin by ID  # noqa: E501

        Retrieve operation of resource: custom-plugin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CustomPluginSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_byoi_custom_plugin_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_byoi_custom_plugin_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/custom-plugin/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomPluginSchema',  # 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 retrieve_healthbot_ingest_byoi_custom_plugins(self, **kwargs):  # noqa: E501
        """Retrieve custom-plugin by ID  # noqa: E501

        Retrieve all the custom-plugins configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_custom_plugins(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CustomPluginSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_byoi_custom_plugins_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_byoi_custom_plugins_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_byoi_custom_plugins_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve custom-plugin by ID  # noqa: E501

        Retrieve all the custom-plugins configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_custom_plugins_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CustomPluginSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_byoi_custom_plugins" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/custom-plugins/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomPluginSchema',  # 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 retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve tlive-kafka-oc by ID  # noqa: E501

        Retrieve operation of resource: tlive-kafka-oc  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TliveKafkaOcSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve tlive-kafka-oc by ID  # noqa: E501

        Retrieve operation of resource: tlive-kafka-oc  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TliveKafkaOcSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/default-plugin/tlive-kafka-oc/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TliveKafkaOcSchema',  # 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 retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafkas(self, **kwargs):  # noqa: E501
        """Retrieve tlive-kafka-oc  # noqa: E501

        Retrieve all the tlive-kafka-ocs configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafkas(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafkas_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafkas_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafkas_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve tlive-kafka-oc  # noqa: E501

        Retrieve all the tlive-kafka-ocs configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafkas_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_byoi_default_plugin_tlive_kafkas" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/default-plugin/tlive-kafka-ocs/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_byoi_ingest_mapping_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve ingest-mapping by ID  # noqa: E501

        Retrieve ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_ingest_mapping_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: IngestMappingSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve ingest-mapping by ID  # noqa: E501

        Retrieve ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: IngestMappingSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_byoi_ingest_mapping_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_byoi_ingest_mapping_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/ingest-mapping/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='IngestMappingSchema',  # 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 retrieve_healthbot_ingest_byoi_ingest_mappings(self, **kwargs):  # noqa: E501
        """Retrieve ingest-mapping  # noqa: E501

        Retrieve all the ingest mappings configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_ingest_mappings(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_byoi_ingest_mappings_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_byoi_ingest_mappings_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_byoi_ingest_mappings_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve ingest-mapping  # noqa: E501

        Retrieve all the ingest mappings configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_byoi_ingest_mappings_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_byoi_ingest_mappings" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/ingest-mappings/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_frequency_profile(self, **kwargs):  # noqa: E501
        """Retrieve frequency-profile  # noqa: E501

        Retrieve operation of resource: frequency-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_frequency_profile(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_frequency_profile_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_frequency_profile_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_frequency_profile_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve frequency-profile  # noqa: E501

        Retrieve operation of resource: frequency-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_frequency_profile_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_frequency_profile" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/frequency-profiles/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_frequency_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve frequency-profile by ID  # noqa: E501

        Retrieve operation of resource: frequency-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_frequency_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FrequencyProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_frequency_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_frequency_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_frequency_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve frequency-profile by ID  # noqa: E501

        Retrieve operation of resource: frequency-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_frequency_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FrequencyProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_frequency_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_frequency_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/frequency-profile/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FrequencyProfileSchema',  # 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 retrieve_healthbot_ingest_outbound_ssh(self, **kwargs):  # noqa: E501
        """Retrieve outbound-ssh  # noqa: E501

        Retrieve operation of resource: outbound-ssh  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_outbound_ssh(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :param str x_iam_token: authentication header object
        :return: OutboundSshSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_outbound_ssh_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_outbound_ssh_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_outbound_ssh_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve outbound-ssh  # noqa: E501

        Retrieve operation of resource: outbound-ssh  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_outbound_ssh_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :param str x_iam_token: authentication header object
        :return: OutboundSshSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['working', 'x_iam_token']  # 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 retrieve_healthbot_ingest_outbound_ssh" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/outbound-ssh/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='OutboundSshSchema',  # 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 retrieve_healthbot_ingest_settings_byoi_custom_plugin_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve custom-plugin by ID  # noqa: E501

        Retrieve operation of resource: custom-plugin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_custom_plugin_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CustomPluginSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve custom-plugin by ID  # noqa: E501

        Retrieve operation of resource: custom-plugin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CustomPluginSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_byoi_custom_plugin_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_settings_byoi_custom_plugin_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/custom-plugin/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomPluginSchema',  # 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 retrieve_healthbot_ingest_settings_byoi_custom_plugins(self, **kwargs):  # noqa: E501
        """Retrieve custom-plugin by ID  # noqa: E501

        Retrieve all the custom-plugins configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_custom_plugins(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CustomPluginSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_byoi_custom_plugins_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_byoi_custom_plugins_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_byoi_custom_plugins_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve custom-plugin by ID  # noqa: E501

        Retrieve all the custom-plugins configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_custom_plugins_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CustomPluginSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_byoi_custom_plugins" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/custom-plugins/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomPluginSchema',  # 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 retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve tlive-kafka-oc by ID  # noqa: E501

        Retrieve operation of resource: tlive-kafka-oc  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TliveKafkaOcSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve tlive-kafka-oc by ID  # noqa: E501

        Retrieve operation of resource: tlive-kafka-oc  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TliveKafkaOcSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/default-plugin/tlive-kafka-oc/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TliveKafkaOcSchema',  # 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 retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafkas(self, **kwargs):  # noqa: E501
        """Retrieve tlive-kafka-oc  # noqa: E501

        Retrieve all the tlive-kafka-ocs configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafkas(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafkas_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafkas_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafkas_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve tlive-kafka-oc  # noqa: E501

        Retrieve all the tlive-kafka-ocs configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafkas_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_byoi_default_plugin_tlive_kafkas" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/default-plugin/tlive-kafka-ocs/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_settings_byoi_ingest_mapping_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve ingest-mapping by ID  # noqa: E501

        Retrieve ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_ingest_mapping_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: IngestMappingSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve ingest-mapping by ID  # noqa: E501

        Retrieve ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: IngestMappingSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_byoi_ingest_mapping_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_settings_byoi_ingest_mapping_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/ingest-mapping/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='IngestMappingSchema',  # 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 retrieve_healthbot_ingest_settings_byoi_ingest_mappings(self, **kwargs):  # noqa: E501
        """Retrieve ingest-mapping  # noqa: E501

        Retrieve all the ingest mappings configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_ingest_mappings(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_byoi_ingest_mappings_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_byoi_ingest_mappings_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_byoi_ingest_mappings_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve ingest-mapping  # noqa: E501

        Retrieve all the ingest mappings configured.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_byoi_ingest_mappings_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_byoi_ingest_mappings" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/ingest-mappings/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_settings_frequency_profile(self, **kwargs):  # noqa: E501
        """Retrieve frequency-profile  # noqa: E501

        Retrieve operation of resource: frequency-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_frequency_profile(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_frequency_profile_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_frequency_profile_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_frequency_profile_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve frequency-profile  # noqa: E501

        Retrieve operation of resource: frequency-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_frequency_profile_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_frequency_profile" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/frequency-profiles/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_settings_frequency_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve frequency-profile by ID  # noqa: E501

        Retrieve operation of resource: frequency-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_frequency_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FrequencyProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve frequency-profile by ID  # noqa: E501

        Retrieve operation of resource: frequency-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FrequencyProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_frequency_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_settings_frequency_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/frequency-profile/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FrequencyProfileSchema',  # 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 retrieve_healthbot_ingest_settings_tagging_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve tagging-profile by ID  # noqa: E501

        Retrieve operation of resource: tagging-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_tagging_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TaggingProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve tagging-profile by ID  # noqa: E501

        Retrieve operation of resource: tagging-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TaggingProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_tagging_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_settings_tagging_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/data-enrichment/tagging-profile/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TaggingProfileSchema',  # 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 retrieve_healthbot_ingest_settings_tagging_profiles(self, **kwargs):  # noqa: E501
        """Retrieve tagging-profile by ID  # noqa: E501

        Retrieve operation of resource: tagging-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_tagging_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_settings_tagging_profiles_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_settings_tagging_profiles_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_settings_tagging_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve tagging-profile by ID  # noqa: E501

        Retrieve operation of resource: tagging-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_settings_tagging_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_settings_tagging_profiles" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/data-enrichment/tagging-profiles/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_sflow(self, **kwargs):  # noqa: E501
        """Retrieve sflow  # noqa: E501

        Retrieve operation of resource: sflow  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SflowSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_sflow_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_sflow_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_sflow_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve sflow  # noqa: E501

        Retrieve operation of resource: sflow  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SflowSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_sflow" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SflowSchema',  # 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 retrieve_healthbot_ingest_sflow_counter_record_by_id(self, record_name, **kwargs):  # noqa: E501
        """Retrieve counter-record by ID  # noqa: E501

        Retrieve operation of resource: counter-record  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_counter_record_by_id(record_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CounterRecordSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_sflow_counter_record_by_id_with_http_info(self, record_name, **kwargs):  # noqa: E501
        """Retrieve counter-record by ID  # noqa: E501

        Retrieve operation of resource: counter-record  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CounterRecordSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['record_name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_sflow_counter_record_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'record_name' is set
        if ('record_name' not in params or
                params['record_name'] is None):
            raise ValueError("Missing the required parameter `record_name` when calling `retrieve_healthbot_ingest_sflow_counter_record_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'record_name' in params:
            path_params['record_name'] = params['record_name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/counter-record/{record_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CounterRecordSchema',  # 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 retrieve_healthbot_ingest_sflow_flow_record_by_id(self, record_name, **kwargs):  # noqa: E501
        """Retrieve flow-record by ID  # noqa: E501

        Retrieve operation of resource: flow-record  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_flow_record_by_id(record_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FlowRecordSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_sflow_flow_record_by_id_with_http_info(self, record_name, **kwargs):  # noqa: E501
        """Retrieve flow-record by ID  # noqa: E501

        Retrieve operation of resource: flow-record  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FlowRecordSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['record_name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_sflow_flow_record_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'record_name' is set
        if ('record_name' not in params or
                params['record_name'] is None):
            raise ValueError("Missing the required parameter `record_name` when calling `retrieve_healthbot_ingest_sflow_flow_record_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'record_name' in params:
            path_params['record_name'] = params['record_name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/flow-record/{record_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FlowRecordSchema',  # 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 retrieve_healthbot_ingest_sflow_protocol_by_id(self, protocol_name, **kwargs):  # noqa: E501
        """Retrieve protocol by ID  # noqa: E501

        Retrieve operation of resource: protocol  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_protocol_by_id(protocol_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str protocol_name: ID of protocol-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: ProtocolSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_sflow_protocol_by_id_with_http_info(self, protocol_name, **kwargs):  # noqa: E501
        """Retrieve protocol by ID  # noqa: E501

        Retrieve operation of resource: protocol  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str protocol_name: ID of protocol-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: ProtocolSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['protocol_name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_sflow_protocol_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'protocol_name' is set
        if ('protocol_name' not in params or
                params['protocol_name'] is None):
            raise ValueError("Missing the required parameter `protocol_name` when calling `retrieve_healthbot_ingest_sflow_protocol_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'protocol_name' in params:
            path_params['protocol_name'] = params['protocol_name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/protocol/{protocol_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ProtocolSchema',  # 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 retrieve_healthbot_ingest_sflow_sample_by_id(self, sample_name, **kwargs):  # noqa: E501
        """Retrieve sample by ID  # noqa: E501

        Retrieve operation of resource: sample  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_sample_by_id(sample_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sample_name: ID of sample-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SampleSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_sflow_sample_by_id_with_http_info(self, sample_name, **kwargs):  # noqa: E501
        """Retrieve sample by ID  # noqa: E501

        Retrieve operation of resource: sample  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sample_name: ID of sample-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SampleSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sample_name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_sflow_sample_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'sample_name' is set
        if ('sample_name' not in params or
                params['sample_name'] is None):
            raise ValueError("Missing the required parameter `sample_name` when calling `retrieve_healthbot_ingest_sflow_sample_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sample_name' in params:
            path_params['sample_name'] = params['sample_name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/sample/{sample_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SampleSchema',  # 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 retrieve_healthbot_ingest_snmp_notification(self, **kwargs):  # noqa: E501
        """Retrieve snmp-notification  # noqa: E501

        Retrieve operation of resource: snmp-notification  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_snmp_notification(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SnmpNotificationSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_snmp_notification_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_snmp_notification_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_snmp_notification_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve snmp-notification  # noqa: E501

        Retrieve operation of resource: snmp-notification  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_snmp_notification_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SnmpNotificationSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_snmp_notification" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SnmpNotificationSchema',  # 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 retrieve_healthbot_ingest_snmp_notification_v3_usm_user_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve SNMPv3 user by UserName(ID)  # noqa: E501

        Retrieve operation of resource: snmp v3 usm user  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_snmp_notification_v3_usm_user_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: User Name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: Snmpv3UsmUserSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve SNMPv3 user by UserName(ID)  # noqa: E501

        Retrieve operation of resource: snmp v3 usm user  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: User Name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: Snmpv3UsmUserSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_snmp_notification_v3_usm_user_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_snmp_notification_v3_usm_user_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/v3/usm/user/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Snmpv3UsmUserSchema',  # 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 retrieve_healthbot_ingest_snmp_notification_v3_usm_usernames(self, **kwargs):  # noqa: E501
        """Retrieve snmp v3 usm user names  # noqa: E501

        Retrieve operation of resource: snmp v3 usm user names  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_snmp_notification_v3_usm_usernames(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_snmp_notification_v3_usm_usernames_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_snmp_notification_v3_usm_usernames_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_snmp_notification_v3_usm_usernames_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve snmp v3 usm user names  # noqa: E501

        Retrieve operation of resource: snmp v3 usm user names  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_snmp_notification_v3_usm_usernames_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_snmp_notification_v3_usm_usernames" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/v3/usm/user/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_snmp_notification_v3_usm_users(self, **kwargs):  # noqa: E501
        """Retrieve SNMP v3 USM users  # noqa: E501

        Retrieve operation of resource: SNMP v3 USM users  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_snmp_notification_v3_usm_users(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[Snmpv3UsmUsersSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_snmp_notification_v3_usm_users_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_snmp_notification_v3_usm_users_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_snmp_notification_v3_usm_users_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve SNMP v3 USM users  # noqa: E501

        Retrieve operation of resource: SNMP v3 USM users  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_snmp_notification_v3_usm_users_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[Snmpv3UsmUsersSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_snmp_notification_v3_usm_users" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/v3/usm/users/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Snmpv3UsmUsersSchema]',  # 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 retrieve_healthbot_ingest_syslog_header_pattern_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: header-pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_syslog_header_pattern_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: HeaderPatternSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: header-pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: HeaderPatternSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_syslog_header_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_syslog_header_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/header-pattern/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='HeaderPatternSchema',  # 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 retrieve_healthbot_ingest_syslog_header_pattern_ids(self, **kwargs):  # noqa: E501
        """Retrieve header pattern names  # noqa: E501

        Retrieve operation of resource: header-pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_syslog_header_pattern_ids(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_syslog_header_pattern_ids_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_syslog_header_pattern_ids_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_syslog_header_pattern_ids_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve header pattern names  # noqa: E501

        Retrieve operation of resource: header-pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_syslog_header_pattern_ids_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_syslog_header_pattern_ids" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/header-pattern/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_ingest_syslog_header_patterns(self, **kwargs):  # noqa: E501
        """Retrieve header patterns  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_syslog_header_patterns(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[HeaderPatternSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_syslog_header_patterns_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_syslog_header_patterns_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_syslog_header_patterns_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve header patterns  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_syslog_header_patterns_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[HeaderPatternSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_syslog_header_patterns" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/header-patterns/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[HeaderPatternSchema]',  # 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 retrieve_healthbot_ingest_tagging_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve tagging-profile by ID  # noqa: E501

        Retrieve operation of resource: tagging-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_tagging_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TaggingProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_tagging_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_tagging_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_tagging_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve tagging-profile by ID  # noqa: E501

        Retrieve operation of resource: tagging-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_tagging_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TaggingProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_tagging_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_healthbot_ingest_tagging_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/data-enrichment/tagging-profile/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TaggingProfileSchema',  # 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 retrieve_healthbot_ingest_tagging_profiles(self, **kwargs):  # noqa: E501
        """Retrieve tagging-profile by ID  # noqa: E501

        Retrieve operation of resource: tagging-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_tagging_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_ingest_tagging_profiles_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_ingest_tagging_profiles_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_ingest_tagging_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve tagging-profile by ID  # noqa: E501

        Retrieve operation of resource: tagging-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_ingest_tagging_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_healthbot_ingest_tagging_profiles" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/data-enrichment/tagging-profiles/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_organization_organization(self, **kwargs):  # noqa: E501
        """Retrieve organization  # noqa: E501

        Retrieve operation of resource: organization  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_organization_organization(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_organization_organization_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_organization_organization_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_organization_organization_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve organization  # noqa: E501

        Retrieve operation of resource: organization  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_organization_organization_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['working']  # 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 retrieve_healthbot_organization_organization" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/organization/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_organization_organization_by_id(self, organization_name, **kwargs):  # noqa: E501
        """Retrieve organization by ID  # noqa: E501

        Retrieve operation of resource: organization  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_organization_organization_by_id(organization_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str organization_name: ID of organization-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: OrganizationSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_organization_organization_by_id_with_http_info(organization_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_organization_organization_by_id_with_http_info(organization_name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_organization_organization_by_id_with_http_info(self, organization_name, **kwargs):  # noqa: E501
        """Retrieve organization by ID  # noqa: E501

        Retrieve operation of resource: organization  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_organization_organization_by_id_with_http_info(organization_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str organization_name: ID of organization-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: OrganizationSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['organization_name', 'x_iam_token', 'working']  # 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 retrieve_healthbot_organization_organization_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'organization_name' is set
        if ('organization_name' not in params or
                params['organization_name'] is None):
            raise ValueError("Missing the required parameter `organization_name` when calling `retrieve_healthbot_organization_organization_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'organization_name' in params:
            path_params['organization_name'] = params['organization_name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/organization/{organization_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='OrganizationSchema',  # 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 retrieve_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id(self, profile_id, **kwargs):  # noqa: E501
        """Retrieve field-profile by ID  # noqa: E501

        Retrieve operation of resource: field-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id(profile_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str profile_id: ID of profile-id (required)
        :param bool working: true queries undeployed configuration
        :param str x_iam_token: authentication header object
        :return: RollupSummarizationSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(self, profile_id, **kwargs):  # noqa: E501
        """Retrieve field-profile by ID  # noqa: E501

        Retrieve operation of resource: field-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str profile_id: ID of profile-id (required)
        :param bool working: true queries undeployed configuration
        :param str x_iam_token: authentication header object
        :return: RollupSummarizationSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['profile_id', 'working', 'x_iam_token']  # 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 retrieve_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'profile_id' is set
        if ('profile_id' not in params or
                params['profile_id'] is None):
            raise ValueError("Missing the required parameter `profile_id` when calling `retrieve_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'profile_id' in params:
            path_params['profile_id'] = params['profile_id']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/rollup-summarization/field-profile/{profile_id}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RollupSummarizationSchema',  # 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 retrieve_healthbot_profile_rollup_summarization_field_profile_profile(self, **kwargs):  # noqa: E501
        """Retrieve field-profile  # noqa: E501

        Retrieve operation of resource: field-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_profile_rollup_summarization_field_profile_profile(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :param str x_iam_token: authentication header object
        :return: RollupSummarizationsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_profile_rollup_summarization_field_profile_profile_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_profile_rollup_summarization_field_profile_profile_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_profile_rollup_summarization_field_profile_profile_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve field-profile  # noqa: E501

        Retrieve operation of resource: field-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_profile_rollup_summarization_field_profile_profile_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :param str x_iam_token: authentication header object
        :return: RollupSummarizationsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['working', 'x_iam_token']  # 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 retrieve_healthbot_profile_rollup_summarization_field_profile_profile" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/rollup-summarization/field-profile/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RollupSummarizationsSchema',  # 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 retrieve_healthbot_system_time_series_database_time_series_database(self, **kwargs):  # noqa: E501
        """Retrieve time-series-database  # noqa: E501

        Retrieve operation of resource: time-series-database  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_system_time_series_database_time_series_database(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :return: TsdbSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_system_time_series_database_time_series_database_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_system_time_series_database_time_series_database_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_system_time_series_database_time_series_database_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve time-series-database  # noqa: E501

        Retrieve operation of resource: time-series-database  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_system_time_series_database_time_series_database_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :return: TsdbSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['working']  # 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 retrieve_healthbot_system_time_series_database_time_series_database" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/system/tsdb/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TsdbSchema',  # 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 retrieve_healthbot_system_trigger_action(self, **kwargs):  # noqa: E501
        """Retrieve trigger-action  # noqa: E501

        Retrieve operation of resource: trigger-action  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_system_trigger_action(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :return: TriggerActionSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_system_trigger_action_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_system_trigger_action_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_system_trigger_action_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve trigger-action  # noqa: E501

        Retrieve operation of resource: trigger-action  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_system_trigger_action_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param bool working: true queries undeployed configuration
        :return: TriggerActionSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['working']  # 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 retrieve_healthbot_system_trigger_action" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/system/trigger_action/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TriggerActionSchema',  # 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 retrieve_healthbot_topic_resource_resource(self, topic_name, **kwargs):  # noqa: E501
        """List all resource-names in a topic  # noqa: E501

        Get a list of all the resource-name`s in a topic  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_topic_resource_resource(topic_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str authorization: authentication header object
        :param bool working: true queries un-committed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_topic_resource_resource_with_http_info(topic_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_topic_resource_resource_with_http_info(topic_name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_topic_resource_resource_with_http_info(self, topic_name, **kwargs):  # noqa: E501
        """List all resource-names in a topic  # noqa: E501

        Get a list of all the resource-name`s in a topic  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_topic_resource_resource_with_http_info(topic_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str authorization: authentication header object
        :param bool working: true queries un-committed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['topic_name', 'authorization', 'working']  # 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 retrieve_healthbot_topic_resource_resource" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'topic_name' is set
        if ('topic_name' not in params or
                params['topic_name'] is None):
            raise ValueError("Missing the required parameter `topic_name` when calling `retrieve_healthbot_topic_resource_resource`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/topic/{topic_name}/resource/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_healthbot_topic_resource_resource_by_id(self, topic_name, resource_name, **kwargs):  # noqa: E501
        """Get a resource's configuration  # noqa: E501

        Get the configuration details of a resource by `resource-name`  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_topic_resource_resource_by_id(topic_name, resource_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str resource_name: ID of resource-name (required)
        :param str authorization: authentication header object
        :param bool working: true queries un-committed configuration
        :param bool download: Download a compressed .resource file
        :return: ResourceSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_healthbot_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, **kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_topic_resource_resource_by_id_with_http_info(self, topic_name, resource_name, **kwargs):  # noqa: E501
        """Get a resource's configuration  # noqa: E501

        Get the configuration details of a resource by `resource-name`  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_healthbot_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str resource_name: ID of resource-name (required)
        :param str authorization: authentication header object
        :param bool working: true queries un-committed configuration
        :param bool download: Download a compressed .resource file
        :return: ResourceSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['topic_name', 'resource_name', 'authorization', 'working', 'download']  # 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 retrieve_healthbot_topic_resource_resource_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'topic_name' is set
        if ('topic_name' not in params or
                params['topic_name'] is None):
            raise ValueError("Missing the required parameter `topic_name` when calling `retrieve_healthbot_topic_resource_resource_by_id`")  # noqa: E501
        # verify the required parameter 'resource_name' is set
        if ('resource_name' not in params or
                params['resource_name'] is None):
            raise ValueError("Missing the required parameter `resource_name` when calling `retrieve_healthbot_topic_resource_resource_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_name']  # noqa: E501
        if 'resource_name' in params:
            path_params['resource_name'] = params['resource_name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501
        if 'download' in params:
            query_params.append(('download', params['download']))  # noqa: E501

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/topic/{topic_name}/resource/{resource_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceSchema',  # 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 retrieve_iceberg_ingest(self, **kwargs):  # noqa: E501
        """Retrieve ingest  # noqa: E501

        Retrieve operation of resource: ingest  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: IngestSettingsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve ingest  # noqa: E501

        Retrieve operation of resource: ingest  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: IngestSettingsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='IngestSettingsSchema',  # 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 retrieve_iceberg_ingest_flow(self, **kwargs):  # noqa: E501
        """Retrieve flow  # noqa: E501

        Retrieve operation of resource: flow  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_flow(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FlowSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_flow_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_flow_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_flow_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve flow  # noqa: E501

        Retrieve operation of resource: flow  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_flow_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FlowSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_flow" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FlowSchema',  # 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 retrieve_iceberg_ingest_flow_template_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve template by ID  # noqa: E501

        Retrieve operation of resource: template  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_flow_template_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TemplateSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_flow_template_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_flow_template_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_flow_template_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve template by ID  # noqa: E501

        Retrieve operation of resource: template  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_flow_template_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TemplateSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_flow_template_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_ingest_flow_template_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/template/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TemplateSchema',  # 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 retrieve_iceberg_ingest_flow_template_ids(self, **kwargs):  # noqa: E501
        """Retrieve template  # noqa: E501

        Retrieve operation of resource: template  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_flow_template_ids(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_flow_template_ids_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_flow_template_ids_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_flow_template_ids_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve template  # noqa: E501

        Retrieve operation of resource: template  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_flow_template_ids_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_flow_template_ids" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/template/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_ingest_native_gpb(self, **kwargs):  # noqa: E501
        """Retrieve native-gpb  # noqa: E501

        Retrieve operation of resource: native-gpb  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_native_gpb(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: NativeGpbSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_native_gpb_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_native_gpb_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_native_gpb_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve native-gpb  # noqa: E501

        Retrieve operation of resource: native-gpb  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_native_gpb_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: NativeGpbSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_native_gpb" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/native-gpb/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NativeGpbSchema',  # 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 retrieve_iceberg_ingest_settings(self, **kwargs):  # noqa: E501
        """Retrieve ingest-settings  # noqa: E501

        Retrieve operation of resource: ingest-settings  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: IngestSettingsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve ingest-settings  # noqa: E501

        Retrieve operation of resource: ingest-settings  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: IngestSettingsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='IngestSettingsSchema',  # 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 retrieve_iceberg_ingest_settings_flow(self, **kwargs):  # noqa: E501
        """Retrieve flow  # noqa: E501

        Retrieve operation of resource: flow  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_flow(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FlowSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_flow_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_flow_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_flow_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve flow  # noqa: E501

        Retrieve operation of resource: flow  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_flow_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: FlowSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_flow" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FlowSchema',  # 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 retrieve_iceberg_ingest_settings_flow_template_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve template by ID  # noqa: E501

        Retrieve operation of resource: template  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_flow_template_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TemplateSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_flow_template_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve template by ID  # noqa: E501

        Retrieve operation of resource: template  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: TemplateSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_flow_template_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_ingest_settings_flow_template_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/template/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TemplateSchema',  # 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 retrieve_iceberg_ingest_settings_flow_template_ids(self, **kwargs):  # noqa: E501
        """Retrieve template  # noqa: E501

        Retrieve operation of resource: template  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_flow_template_ids(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_flow_template_ids_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_flow_template_ids_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_flow_template_ids_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve template  # noqa: E501

        Retrieve operation of resource: template  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_flow_template_ids_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_flow_template_ids" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/template/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_ingest_settings_syslog(self, **kwargs):  # noqa: E501
        """Retrieve syslog  # noqa: E501

        Retrieve operation of resource: syslog  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SyslogSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_syslog_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_syslog_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_syslog_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve syslog  # noqa: E501

        Retrieve operation of resource: syslog  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SyslogSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_syslog" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SyslogSchema',  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: PatternSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: PatternSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_ingest_settings_syslog_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PatternSchema',  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_ids(self, **kwargs):  # noqa: E501
        """Retrieve pattern  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_ids(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_syslog_pattern_ids_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_syslog_pattern_ids_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_syslog_pattern_ids_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve pattern  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_ids_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_ids" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_set_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern-set by ID  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_set_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of patter-set (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: PatternSetSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern-set by ID  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of patter-set (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: PatternSetSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_set_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_ingest_settings_syslog_pattern_set_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern-set/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PatternSetSchema',  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_set_ids(self, **kwargs):  # noqa: E501
        """Retrieve pattern-set  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_set_ids(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_syslog_pattern_set_ids_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_syslog_pattern_set_ids_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_syslog_pattern_set_ids_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve pattern-set  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_set_ids_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_set_ids" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern-set/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_sets(self, **kwargs):  # noqa: E501
        """Retrieve pattern-set by ID  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_sets(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[PatternSetSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_syslog_pattern_sets_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_syslog_pattern_sets_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_syslog_pattern_sets_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve pattern-set by ID  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_pattern_sets_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[PatternSetSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_syslog_pattern_sets" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern-sets/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[PatternSetSchema]',  # 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 retrieve_iceberg_ingest_settings_syslog_patterns(self, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_patterns(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[PatternSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_settings_syslog_patterns_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_settings_syslog_patterns_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_settings_syslog_patterns_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_settings_syslog_patterns_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[PatternSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_settings_syslog_patterns" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/patterns/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[PatternSchema]',  # 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 retrieve_iceberg_ingest_syslog(self, **kwargs):  # noqa: E501
        """Retrieve syslog  # noqa: E501

        Retrieve operation of resource: syslog  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SyslogSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_syslog_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_syslog_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_syslog_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve syslog  # noqa: E501

        Retrieve operation of resource: syslog  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SyslogSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_syslog" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SyslogSchema',  # 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 retrieve_iceberg_ingest_syslog_pattern_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: PatternSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_syslog_pattern_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: PatternSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_syslog_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_ingest_syslog_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PatternSchema',  # 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 retrieve_iceberg_ingest_syslog_pattern_ids(self, **kwargs):  # noqa: E501
        """Retrieve pattern  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_ids(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_syslog_pattern_ids_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_syslog_pattern_ids_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_syslog_pattern_ids_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve pattern  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_ids_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_syslog_pattern_ids" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_ingest_syslog_pattern_set_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern-set by ID  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_set_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: PatternSetSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve pattern-set by ID  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: PatternSetSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_syslog_pattern_set_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_ingest_syslog_pattern_set_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern-set/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PatternSetSchema',  # 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 retrieve_iceberg_ingest_syslog_pattern_set_ids(self, **kwargs):  # noqa: E501
        """Retrieve pattern-set  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_set_ids(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_syslog_pattern_set_ids_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_syslog_pattern_set_ids_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_syslog_pattern_set_ids_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve pattern-set  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_set_ids_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_syslog_pattern_set_ids" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern-set/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_ingest_syslog_pattern_sets(self, **kwargs):  # noqa: E501
        """Retrieve pattern-set by ID  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_sets(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[PatternSetSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_syslog_pattern_sets_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_syslog_pattern_sets_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_syslog_pattern_sets_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve pattern-set by ID  # noqa: E501

        Retrieve operation of resource: pattern-set  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_pattern_sets_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[PatternSetSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_syslog_pattern_sets" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern-sets/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[PatternSetSchema]',  # 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 retrieve_iceberg_ingest_syslog_patterns(self, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_patterns(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[PatternSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_ingest_syslog_patterns_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_ingest_syslog_patterns_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_ingest_syslog_patterns_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve pattern by ID  # noqa: E501

        Retrieve operation of resource: pattern  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_ingest_syslog_patterns_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[PatternSchema]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_ingest_syslog_patterns" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/patterns/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[PatternSchema]',  # 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 retrieve_iceberg_profile_data_summarization_raw_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve raw-data-summarization by ID  # noqa: E501

        Retrieve operation of resource: raw-data-summarization  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_data_summarization_raw_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of raw-data-summarization (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: RawSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profile_data_summarization_raw_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve raw-data-summarization by ID  # noqa: E501

        Retrieve operation of resource: raw-data-summarization  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of raw-data-summarization (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: RawSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_profile_data_summarization_raw_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_profile_data_summarization_raw_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/data-summarization/raw/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RawSchema',  # 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 retrieve_iceberg_profile_data_summarizations_raw(self, **kwargs):  # noqa: E501
        """Retrieve raw-data-summarization  # noqa: E501

        Retrieve operation of resource: raw-data-summarization  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_data_summarizations_raw(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: RawSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profile_data_summarizations_raw_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profile_data_summarizations_raw_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profile_data_summarizations_raw_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve raw-data-summarization  # noqa: E501

        Retrieve operation of resource: raw-data-summarization  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_data_summarizations_raw_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: RawSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_profile_data_summarizations_raw" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/data-summarizations/raw/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RawSchema',  # 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 retrieve_iceberg_profile_security_ca_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve ca-profile by ID  # noqa: E501

        Retrieve operation of resource: ca-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_ca_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ca-profile (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CaProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profile_security_ca_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profile_security_ca_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profile_security_ca_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve ca-profile by ID  # noqa: E501

        Retrieve operation of resource: ca-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_ca_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ca-profile (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: CaProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_profile_security_ca_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_profile_security_ca_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ca-profile/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CaProfileSchema',  # 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 retrieve_iceberg_profile_security_ca_profiles(self, **kwargs):  # noqa: E501
        """Retrieve ca-profile  # noqa: E501

        Retrieve entire ca-profiles configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_ca_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profile_security_ca_profiles_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profile_security_ca_profiles_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profile_security_ca_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve ca-profile  # noqa: E501

        Retrieve entire ca-profiles configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_ca_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_profile_security_ca_profiles" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ca-profiles/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_profile_security_local_certificate_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve local-certificate by ID  # noqa: E501

        Retrieve operation of resource: local-certificate  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_local_certificate_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of local-certificate (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: LocalCertificateSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profile_security_local_certificate_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profile_security_local_certificate_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profile_security_local_certificate_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve local-certificate by ID  # noqa: E501

        Retrieve operation of resource: local-certificate  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_local_certificate_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of local-certificate (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: LocalCertificateSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'x_iam_token', 'working']  # 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 retrieve_iceberg_profile_security_local_certificate_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_profile_security_local_certificate_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/local-certificate/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='LocalCertificateSchema',  # 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 retrieve_iceberg_profile_security_local_certificates(self, **kwargs):  # noqa: E501
        """Retrieve local-certificate  # noqa: E501

        Retrieve entire local-certificates configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_local_certificates(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profile_security_local_certificates_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profile_security_local_certificates_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profile_security_local_certificates_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve local-certificate  # noqa: E501

        Retrieve entire local-certificates configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_local_certificates_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_profile_security_local_certificates" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/local-certificates/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_profile_security_ssh_key_profile_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve ssh-key-profile by ID  # noqa: E501

        Retrieve operation of resource: ssh-key-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_ssh_key_profile_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ssh-key-profile (required)
        :param str authorization: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SshKeyProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve ssh-key-profile by ID  # noqa: E501

        Retrieve operation of resource: ssh-key-profile  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ssh-key-profile (required)
        :param str authorization: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SshKeyProfileSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'authorization', 'working']  # 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 retrieve_iceberg_profile_security_ssh_key_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `retrieve_iceberg_profile_security_ssh_key_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ssh-key-profile/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SshKeyProfileSchema',  # 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 retrieve_iceberg_profile_security_ssh_key_profiles(self, **kwargs):  # noqa: E501
        """Retrieve ssh-key-profile  # noqa: E501

        Retrieve entire ssh-key-profiles configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_ssh_key_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str authorization: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profile_security_ssh_key_profiles_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profile_security_ssh_key_profiles_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profile_security_ssh_key_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve ssh-key-profile  # noqa: E501

        Retrieve entire ssh-key-profiles configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profile_security_ssh_key_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str authorization: authentication header object
        :param bool working: true queries undeployed configuration
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['authorization', 'working']  # 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 retrieve_iceberg_profile_security_ssh_key_profiles" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ssh-key-profiles/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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 retrieve_iceberg_profiles(self, **kwargs):  # noqa: E501
        """Retrieve profile  # noqa: E501

        Retrieve entire profile configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: ProfilesSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_iceberg_profiles_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_profiles_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve profile  # noqa: E501

        Retrieve entire profile configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: ProfilesSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working']  # 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 retrieve_iceberg_profiles" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'working' in params:
            query_params.append(('working', params['working']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profiles/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ProfilesSchema',  # 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 retrieve_sensors(self, sensor_type, **kwargs):  # noqa: E501
        """List all OpenConfig sensors.  # noqa: E501

        Get a list of all the sensors for the filters provided. Filtering is possible with the use of query parameters. If you have a sensor `/1/2/3/4/5/6/` and `sensor_name=/1`and `depth=3`, the result would be `/2/3/4`. If you use `append=true`, then the result would be `/1/2/3/4`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_sensors(sensor_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sensor_type: Sensor type (required)
        :param str x_iam_token: authentication header object
        :param str sensor_name: Sensor name prefix.
        :param int depth: Relative depth to the `sensor_name`.
        :param bool append: Returns full path of the sensor.
        :param str snmp_table: Returns list of all the columns for the particular snmp_table
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.retrieve_sensors_with_http_info(sensor_type, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_sensors_with_http_info(sensor_type, **kwargs)  # noqa: E501
            return data

    def retrieve_sensors_with_http_info(self, sensor_type, **kwargs):  # noqa: E501
        """List all OpenConfig sensors.  # noqa: E501

        Get a list of all the sensors for the filters provided. Filtering is possible with the use of query parameters. If you have a sensor `/1/2/3/4/5/6/` and `sensor_name=/1`and `depth=3`, the result would be `/2/3/4`. If you use `append=true`, then the result would be `/1/2/3/4`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_sensors_with_http_info(sensor_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sensor_type: Sensor type (required)
        :param str x_iam_token: authentication header object
        :param str sensor_name: Sensor name prefix.
        :param int depth: Relative depth to the `sensor_name`.
        :param bool append: Returns full path of the sensor.
        :param str snmp_table: Returns list of all the columns for the particular snmp_table
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sensor_type', 'x_iam_token', 'sensor_name', 'depth', 'append', 'snmp_table']  # 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 retrieve_sensors" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'sensor_type' is set
        if ('sensor_type' not in params or
                params['sensor_type'] is None):
            raise ValueError("Missing the required parameter `sensor_type` when calling `retrieve_sensors`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'sensor_name' in params:
            query_params.append(('sensor_name', params['sensor_name']))  # noqa: E501
        if 'sensor_type' in params:
            query_params.append(('sensor_type', params['sensor_type']))  # noqa: E501
        if 'depth' in params:
            query_params.append(('depth', params['depth']))  # noqa: E501
        if 'append' in params:
            query_params.append(('append', params['append']))  # noqa: E501
        if 'snmp_table' in params:
            query_params.append(('snmp_table', params['snmp_table']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/octet-stream'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/sensors/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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_dynamic_tagging_by_key(self, key_name, dynamic_tagging_obj, **kwargs):  # noqa: E501
        """Updates Dynamic-tagging key-value  # noqa: E501

        Update operation of Dynamic-tagging key  # 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_dynamic_tagging_by_key(key_name, dynamic_tagging_obj, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str key_name: Dynamic-tagging Key (required)
        :param DynamicTaggingSchemaObject dynamic_tagging_obj: Dynamic-tagging object containing key-value pair (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_dynamic_tagging_by_key_with_http_info(key_name, dynamic_tagging_obj, **kwargs)  # noqa: E501
        else:
            (data) = self.update_dynamic_tagging_by_key_with_http_info(key_name, dynamic_tagging_obj, **kwargs)  # noqa: E501
            return data

    def update_dynamic_tagging_by_key_with_http_info(self, key_name, dynamic_tagging_obj, **kwargs):  # noqa: E501
        """Updates Dynamic-tagging key-value  # noqa: E501

        Update operation of Dynamic-tagging key  # 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_dynamic_tagging_by_key_with_http_info(key_name, dynamic_tagging_obj, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str key_name: Dynamic-tagging Key (required)
        :param DynamicTaggingSchemaObject dynamic_tagging_obj: Dynamic-tagging object containing key-value pair (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['key_name', 'dynamic_tagging_obj', 'x_iam_token']  # 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_dynamic_tagging_by_key" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'key_name' is set
        if ('key_name' not in params or
                params['key_name'] is None):
            raise ValueError("Missing the required parameter `key_name` when calling `update_dynamic_tagging_by_key`")  # noqa: E501
        # verify the required parameter 'dynamic_tagging_obj' is set
        if ('dynamic_tagging_obj' not in params or
                params['dynamic_tagging_obj'] is None):
            raise ValueError("Missing the required parameter `dynamic_tagging_obj` when calling `update_dynamic_tagging_by_key`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'key_name' in params:
            query_params.append(('key_name', params['key_name']))  # noqa: E501

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'dynamic_tagging_obj' in params:
            body_params = params['dynamic_tagging_obj']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/dynamic-tagging/key/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_deployment_deployment_by_id(self, deployment, **kwargs):  # noqa: E501
        """Update deployment by ID  # noqa: E501

        Update operation of resource: deployment  # 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_healthbot_deployment_deployment_by_id(deployment, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeploymentSchema deployment: deploymentbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_deployment_deployment_by_id_with_http_info(deployment, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_deployment_deployment_by_id_with_http_info(deployment, **kwargs)  # noqa: E501
            return data

    def update_healthbot_deployment_deployment_by_id_with_http_info(self, deployment, **kwargs):  # noqa: E501
        """Update deployment by ID  # noqa: E501

        Update operation of resource: deployment  # 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_healthbot_deployment_deployment_by_id_with_http_info(deployment, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeploymentSchema deployment: deploymentbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['deployment', 'x_iam_token']  # 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_healthbot_deployment_deployment_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'deployment' is set
        if ('deployment' not in params or
                params['deployment'] is None):
            raise ValueError("Missing the required parameter `deployment` when calling `update_healthbot_deployment_deployment_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'deployment' in params:
            body_params = params['deployment']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/deployment/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_dynamic_tagging(self, dynamic_tagging, **kwargs):  # noqa: E501
        """Update dynamic-tagging by ID  # noqa: E501

        Update operation of resource: dynamic-tagging  # 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_healthbot_dynamic_tagging(dynamic_tagging, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DynamicTaggingsSchemaObject dynamic_tagging: dynamic_taggingbody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_dynamic_tagging_with_http_info(dynamic_tagging, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_dynamic_tagging_with_http_info(dynamic_tagging, **kwargs)  # noqa: E501
            return data

    def update_healthbot_dynamic_tagging_with_http_info(self, dynamic_tagging, **kwargs):  # noqa: E501
        """Update dynamic-tagging by ID  # noqa: E501

        Update operation of resource: dynamic-tagging  # 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_healthbot_dynamic_tagging_with_http_info(dynamic_tagging, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DynamicTaggingsSchemaObject dynamic_tagging: dynamic_taggingbody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['dynamic_tagging', 'x_iam_token']  # 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_healthbot_dynamic_tagging" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'dynamic_tagging' is set
        if ('dynamic_tagging' not in params or
                params['dynamic_tagging'] is None):
            raise ValueError("Missing the required parameter `dynamic_tagging` when calling `update_healthbot_dynamic_tagging`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'dynamic_tagging' in params:
            body_params = params['dynamic_tagging']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/dynamic-tagging/keys/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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_healthbot_ingest_byoi_custom_plugin_by_id(self, name, custom_plugin, **kwargs):  # noqa: E501
        """Update custom-plugin by ID  # noqa: E501

        Update operation of resource: custom-plugin  # 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_healthbot_ingest_byoi_custom_plugin_by_id(name, custom_plugin, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param CustomPluginSchema custom_plugin: custom_pluginbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(self, name, custom_plugin, **kwargs):  # noqa: E501
        """Update custom-plugin by ID  # noqa: E501

        Update operation of resource: custom-plugin  # 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_healthbot_ingest_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param CustomPluginSchema custom_plugin: custom_pluginbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'custom_plugin', 'x_iam_token']  # 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_healthbot_ingest_byoi_custom_plugin_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_byoi_custom_plugin_by_id`")  # noqa: E501
        # verify the required parameter 'custom_plugin' is set
        if ('custom_plugin' not in params or
                params['custom_plugin'] is None):
            raise ValueError("Missing the required parameter `custom_plugin` when calling `update_healthbot_ingest_byoi_custom_plugin_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'custom_plugin' in params:
            body_params = params['custom_plugin']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/custom-plugin/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id(self, name, tlive_kafka, **kwargs):  # noqa: E501
        """Update tlive-kafka-oc by ID  # noqa: E501

        Update operation of resource: tlive-kafka-oc  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id(name, tlive_kafka, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param TliveKafkaOcSchema tlive_kafka: tlive_kafka body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(self, name, tlive_kafka, **kwargs):  # noqa: E501
        """Update tlive-kafka-oc by ID  # noqa: E501

        Update operation of resource: tlive-kafka-oc  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param TliveKafkaOcSchema tlive_kafka: tlive_kafka body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'tlive_kafka', 'x_iam_token']  # 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_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501
        # verify the required parameter 'tlive_kafka' is set
        if ('tlive_kafka' not in params or
                params['tlive_kafka'] is None):
            raise ValueError("Missing the required parameter `tlive_kafka` when calling `update_healthbot_ingest_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tlive_kafka' in params:
            body_params = params['tlive_kafka']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/default-plugin/tlive-kafka-oc/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_byoi_ingest_mapping_by_id(self, name, ingest_mapping, **kwargs):  # noqa: E501
        """Update ingest-mapping by ID  # noqa: E501

        Update ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_healthbot_ingest_byoi_ingest_mapping_by_id(name, ingest_mapping, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param IngestMappingSchema ingest_mapping: ingest_mappingbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(self, name, ingest_mapping, **kwargs):  # noqa: E501
        """Update ingest-mapping by ID  # noqa: E501

        Update ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_healthbot_ingest_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param IngestMappingSchema ingest_mapping: ingest_mappingbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'ingest_mapping', 'x_iam_token']  # 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_healthbot_ingest_byoi_ingest_mapping_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_byoi_ingest_mapping_by_id`")  # noqa: E501
        # verify the required parameter 'ingest_mapping' is set
        if ('ingest_mapping' not in params or
                params['ingest_mapping'] is None):
            raise ValueError("Missing the required parameter `ingest_mapping` when calling `update_healthbot_ingest_byoi_ingest_mapping_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ingest_mapping' in params:
            body_params = params['ingest_mapping']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/byoi/ingest-mapping/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_frequency_profile_by_id(self, name, frequency_profile, **kwargs):  # noqa: E501
        """Update frequency-profile by ID  # noqa: E501

        Update operation of resource: frequency-profile  # 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_healthbot_ingest_frequency_profile_by_id(name, frequency_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param FrequencyProfileSchema frequency_profile: frequency_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_frequency_profile_by_id_with_http_info(name, frequency_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_frequency_profile_by_id_with_http_info(name, frequency_profile, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_frequency_profile_by_id_with_http_info(self, name, frequency_profile, **kwargs):  # noqa: E501
        """Update frequency-profile by ID  # noqa: E501

        Update operation of resource: frequency-profile  # 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_healthbot_ingest_frequency_profile_by_id_with_http_info(name, frequency_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param FrequencyProfileSchema frequency_profile: frequency_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'frequency_profile', 'x_iam_token']  # 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_healthbot_ingest_frequency_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_frequency_profile_by_id`")  # noqa: E501
        # verify the required parameter 'frequency_profile' is set
        if ('frequency_profile' not in params or
                params['frequency_profile'] is None):
            raise ValueError("Missing the required parameter `frequency_profile` when calling `update_healthbot_ingest_frequency_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'frequency_profile' in params:
            body_params = params['frequency_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/frequency-profile/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_outbound_ssh(self, outbound_ssh, **kwargs):  # noqa: E501
        """Update outbound-ssh by ID  # noqa: E501

        Update operation of resource: outbound-ssh  # 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_healthbot_ingest_outbound_ssh(outbound_ssh, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param OutboundSshSchema outbound_ssh: outbound_sshbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_outbound_ssh_with_http_info(outbound_ssh, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_outbound_ssh_with_http_info(outbound_ssh, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_outbound_ssh_with_http_info(self, outbound_ssh, **kwargs):  # noqa: E501
        """Update outbound-ssh by ID  # noqa: E501

        Update operation of resource: outbound-ssh  # 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_healthbot_ingest_outbound_ssh_with_http_info(outbound_ssh, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param OutboundSshSchema outbound_ssh: outbound_sshbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['outbound_ssh', 'x_iam_token']  # 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_healthbot_ingest_outbound_ssh" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'outbound_ssh' is set
        if ('outbound_ssh' not in params or
                params['outbound_ssh'] is None):
            raise ValueError("Missing the required parameter `outbound_ssh` when calling `update_healthbot_ingest_outbound_ssh`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'outbound_ssh' in params:
            body_params = params['outbound_ssh']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/outbound-ssh/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id(self, name, custom_plugin, **kwargs):  # noqa: E501
        """Update custom-plugin by ID  # noqa: E501

        Update operation of resource: custom-plugin  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id(name, custom_plugin, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param CustomPluginSchema custom_plugin: custom_pluginbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(self, name, custom_plugin, **kwargs):  # noqa: E501
        """Update custom-plugin by ID  # noqa: E501

        Update operation of resource: custom-plugin  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id_with_http_info(name, custom_plugin, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of custom-plugin (required)
        :param CustomPluginSchema custom_plugin: custom_pluginbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'custom_plugin', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_custom_plugin_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_settings_byoi_custom_plugin_by_id`")  # noqa: E501
        # verify the required parameter 'custom_plugin' is set
        if ('custom_plugin' not in params or
                params['custom_plugin'] is None):
            raise ValueError("Missing the required parameter `custom_plugin` when calling `update_healthbot_ingest_settings_byoi_custom_plugin_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'custom_plugin' in params:
            body_params = params['custom_plugin']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/custom-plugin/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id(self, name, tlive_kafka, **kwargs):  # noqa: E501
        """Update tlive-kafka-oc by ID  # noqa: E501

        Update operation of resource: tlive-kafka-oc  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id(name, tlive_kafka, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param TliveKafkaOcSchema tlive_kafka: tlive_kafka body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(self, name, tlive_kafka, **kwargs):  # noqa: E501
        """Update tlive-kafka-oc by ID  # noqa: E501

        Update operation of resource: tlive-kafka-oc  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id_with_http_info(name, tlive_kafka, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of tlive-kafka-oc (required)
        :param TliveKafkaOcSchema tlive_kafka: tlive_kafka body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'tlive_kafka', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501
        # verify the required parameter 'tlive_kafka' is set
        if ('tlive_kafka' not in params or
                params['tlive_kafka'] is None):
            raise ValueError("Missing the required parameter `tlive_kafka` when calling `update_healthbot_ingest_settings_byoi_default_plugin_tlive_kafka_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tlive_kafka' in params:
            body_params = params['tlive_kafka']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/default-plugin/tlive-kafka-oc/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_byoi_ingest_mapping_by_id(self, name, ingest_mapping, **kwargs):  # noqa: E501
        """Update ingest-mapping by ID  # noqa: E501

        Update ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_healthbot_ingest_settings_byoi_ingest_mapping_by_id(name, ingest_mapping, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param IngestMappingSchema ingest_mapping: ingest_mappingbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(self, name, ingest_mapping, **kwargs):  # noqa: E501
        """Update ingest-mapping by ID  # noqa: E501

        Update ingest-mapping by name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_healthbot_ingest_settings_byoi_ingest_mapping_by_id_with_http_info(name, ingest_mapping, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ingest-mapping (required)
        :param IngestMappingSchema ingest_mapping: ingest_mappingbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'ingest_mapping', 'x_iam_token']  # 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_healthbot_ingest_settings_byoi_ingest_mapping_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_settings_byoi_ingest_mapping_by_id`")  # noqa: E501
        # verify the required parameter 'ingest_mapping' is set
        if ('ingest_mapping' not in params or
                params['ingest_mapping'] is None):
            raise ValueError("Missing the required parameter `ingest_mapping` when calling `update_healthbot_ingest_settings_byoi_ingest_mapping_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ingest_mapping' in params:
            body_params = params['ingest_mapping']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/byoi/ingest-mapping/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_frequency_profile_by_id(self, name, frequency_profile, **kwargs):  # noqa: E501
        """Update frequency-profile by ID  # noqa: E501

        Update operation of resource: frequency-profile  # 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_healthbot_ingest_settings_frequency_profile_by_id(name, frequency_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param FrequencyProfileSchema frequency_profile: frequency_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, frequency_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, frequency_profile, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(self, name, frequency_profile, **kwargs):  # noqa: E501
        """Update frequency-profile by ID  # noqa: E501

        Update operation of resource: frequency-profile  # 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_healthbot_ingest_settings_frequency_profile_by_id_with_http_info(name, frequency_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param FrequencyProfileSchema frequency_profile: frequency_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'frequency_profile', 'x_iam_token']  # 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_healthbot_ingest_settings_frequency_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_settings_frequency_profile_by_id`")  # noqa: E501
        # verify the required parameter 'frequency_profile' is set
        if ('frequency_profile' not in params or
                params['frequency_profile'] is None):
            raise ValueError("Missing the required parameter `frequency_profile` when calling `update_healthbot_ingest_settings_frequency_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'frequency_profile' in params:
            body_params = params['frequency_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/frequency-profile/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_tagging_profile_by_id(self, name, tagging_profile, **kwargs):  # noqa: E501
        """Update tagging-profile by ID  # noqa: E501

        Update operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profile_by_id(name, tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param TaggingProfileSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, tagging_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, tagging_profile, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(self, name, tagging_profile, **kwargs):  # noqa: E501
        """Update tagging-profile by ID  # noqa: E501

        Update operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profile_by_id_with_http_info(name, tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param TaggingProfileSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'tagging_profile', 'x_iam_token']  # 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_healthbot_ingest_settings_tagging_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_settings_tagging_profile_by_id`")  # noqa: E501
        # verify the required parameter 'tagging_profile' is set
        if ('tagging_profile' not in params or
                params['tagging_profile'] is None):
            raise ValueError("Missing the required parameter `tagging_profile` when calling `update_healthbot_ingest_settings_tagging_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tagging_profile' in params:
            body_params = params['tagging_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/data-enrichment/tagging-profile/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_settings_tagging_profiles(self, tagging_profiles, **kwargs):  # noqa: E501
        """Update tagging-profile by ID  # noqa: E501

        Update operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profiles(tagging_profiles, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaggingProfilesSchema tagging_profiles: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_settings_tagging_profiles_with_http_info(tagging_profiles, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_settings_tagging_profiles_with_http_info(tagging_profiles, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_settings_tagging_profiles_with_http_info(self, tagging_profiles, **kwargs):  # noqa: E501
        """Update tagging-profile by ID  # noqa: E501

        Update operation of resource: tagging-profile  # 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_healthbot_ingest_settings_tagging_profiles_with_http_info(tagging_profiles, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaggingProfilesSchema tagging_profiles: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['tagging_profiles', 'x_iam_token']  # 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_healthbot_ingest_settings_tagging_profiles" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'tagging_profiles' is set
        if ('tagging_profiles' not in params or
                params['tagging_profiles'] is None):
            raise ValueError("Missing the required parameter `tagging_profiles` when calling `update_healthbot_ingest_settings_tagging_profiles`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tagging_profiles' in params:
            body_params = params['tagging_profiles']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/data-enrichment/tagging-profiles/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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_healthbot_ingest_sflow(self, sflow, **kwargs):  # noqa: E501
        """Update sflow by ID  # noqa: E501

        Update operation of resource: sflow  # 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_healthbot_ingest_sflow(sflow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SflowSchema sflow: sflowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_sflow_with_http_info(sflow, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_sflow_with_http_info(sflow, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_sflow_with_http_info(self, sflow, **kwargs):  # noqa: E501
        """Update sflow by ID  # noqa: E501

        Update operation of resource: sflow  # 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_healthbot_ingest_sflow_with_http_info(sflow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SflowSchema sflow: sflowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sflow', 'x_iam_token']  # 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_healthbot_ingest_sflow" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'sflow' is set
        if ('sflow' not in params or
                params['sflow'] is None):
            raise ValueError("Missing the required parameter `sflow` when calling `update_healthbot_ingest_sflow`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'sflow' in params:
            body_params = params['sflow']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_counter_record_by_id(self, record_name, counter_record, **kwargs):  # noqa: E501
        """Update counter-record by ID  # noqa: E501

        Update operation of resource: counter-record  # 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_healthbot_ingest_sflow_counter_record_by_id(record_name, counter_record, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param CounterRecordSchema counter_record: counter_recordbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, counter_record, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, counter_record, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_sflow_counter_record_by_id_with_http_info(self, record_name, counter_record, **kwargs):  # noqa: E501
        """Update counter-record by ID  # noqa: E501

        Update operation of resource: counter-record  # 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_healthbot_ingest_sflow_counter_record_by_id_with_http_info(record_name, counter_record, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param CounterRecordSchema counter_record: counter_recordbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['record_name', 'counter_record', 'x_iam_token']  # 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_healthbot_ingest_sflow_counter_record_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'record_name' is set
        if ('record_name' not in params or
                params['record_name'] is None):
            raise ValueError("Missing the required parameter `record_name` when calling `update_healthbot_ingest_sflow_counter_record_by_id`")  # noqa: E501
        # verify the required parameter 'counter_record' is set
        if ('counter_record' not in params or
                params['counter_record'] is None):
            raise ValueError("Missing the required parameter `counter_record` when calling `update_healthbot_ingest_sflow_counter_record_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'record_name' in params:
            path_params['record_name'] = params['record_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'counter_record' in params:
            body_params = params['counter_record']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/counter-record/{record_name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_flow_record_by_id(self, record_name, flow_record, **kwargs):  # noqa: E501
        """Update flow-record by ID  # noqa: E501

        Update operation of resource: flow-record  # 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_healthbot_ingest_sflow_flow_record_by_id(record_name, flow_record, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param FlowRecordSchema flow_record: flow_recordbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, flow_record, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, flow_record, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_sflow_flow_record_by_id_with_http_info(self, record_name, flow_record, **kwargs):  # noqa: E501
        """Update flow-record by ID  # noqa: E501

        Update operation of resource: flow-record  # 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_healthbot_ingest_sflow_flow_record_by_id_with_http_info(record_name, flow_record, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str record_name: ID of record-name (required)
        :param FlowRecordSchema flow_record: flow_recordbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['record_name', 'flow_record', 'x_iam_token']  # 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_healthbot_ingest_sflow_flow_record_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'record_name' is set
        if ('record_name' not in params or
                params['record_name'] is None):
            raise ValueError("Missing the required parameter `record_name` when calling `update_healthbot_ingest_sflow_flow_record_by_id`")  # noqa: E501
        # verify the required parameter 'flow_record' is set
        if ('flow_record' not in params or
                params['flow_record'] is None):
            raise ValueError("Missing the required parameter `flow_record` when calling `update_healthbot_ingest_sflow_flow_record_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'record_name' in params:
            path_params['record_name'] = params['record_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'flow_record' in params:
            body_params = params['flow_record']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/flow-record/{record_name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_protocol_by_id(self, protocol_name, protocol, **kwargs):  # noqa: E501
        """Update protocol by ID  # noqa: E501

        Update operation of resource: protocol  # 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_healthbot_ingest_sflow_protocol_by_id(protocol_name, protocol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str protocol_name: ID of protocol-name (required)
        :param ProtocolSchema protocol: protocolbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, protocol, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, protocol, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_sflow_protocol_by_id_with_http_info(self, protocol_name, protocol, **kwargs):  # noqa: E501
        """Update protocol by ID  # noqa: E501

        Update operation of resource: protocol  # 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_healthbot_ingest_sflow_protocol_by_id_with_http_info(protocol_name, protocol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str protocol_name: ID of protocol-name (required)
        :param ProtocolSchema protocol: protocolbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['protocol_name', 'protocol', 'x_iam_token']  # 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_healthbot_ingest_sflow_protocol_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'protocol_name' is set
        if ('protocol_name' not in params or
                params['protocol_name'] is None):
            raise ValueError("Missing the required parameter `protocol_name` when calling `update_healthbot_ingest_sflow_protocol_by_id`")  # noqa: E501
        # verify the required parameter 'protocol' is set
        if ('protocol' not in params or
                params['protocol'] is None):
            raise ValueError("Missing the required parameter `protocol` when calling `update_healthbot_ingest_sflow_protocol_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'protocol_name' in params:
            path_params['protocol_name'] = params['protocol_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'protocol' in params:
            body_params = params['protocol']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/protocol/{protocol_name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_sflow_sample_by_id(self, sample_name, sample, **kwargs):  # noqa: E501
        """Update sample by ID  # noqa: E501

        Update operation of resource: sample  # 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_healthbot_ingest_sflow_sample_by_id(sample_name, sample, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sample_name: ID of sample-name (required)
        :param SampleSchema sample: samplebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, sample, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, sample, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_sflow_sample_by_id_with_http_info(self, sample_name, sample, **kwargs):  # noqa: E501
        """Update sample by ID  # noqa: E501

        Update operation of resource: sample  # 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_healthbot_ingest_sflow_sample_by_id_with_http_info(sample_name, sample, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str sample_name: ID of sample-name (required)
        :param SampleSchema sample: samplebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sample_name', 'sample', 'x_iam_token']  # 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_healthbot_ingest_sflow_sample_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'sample_name' is set
        if ('sample_name' not in params or
                params['sample_name'] is None):
            raise ValueError("Missing the required parameter `sample_name` when calling `update_healthbot_ingest_sflow_sample_by_id`")  # noqa: E501
        # verify the required parameter 'sample' is set
        if ('sample' not in params or
                params['sample'] is None):
            raise ValueError("Missing the required parameter `sample` when calling `update_healthbot_ingest_sflow_sample_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sample_name' in params:
            path_params['sample_name'] = params['sample_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'sample' in params:
            body_params = params['sample']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/sflow/sample/{sample_name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_snmp_notification(self, snmp_notification, **kwargs):  # noqa: E501
        """Update snmp-notification by ID  # noqa: E501

        Update operation of resource: snmp-notification  # 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_healthbot_ingest_snmp_notification(snmp_notification, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SnmpNotificationSchema snmp_notification: snmp_notification body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_snmp_notification_with_http_info(snmp_notification, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_snmp_notification_with_http_info(snmp_notification, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_snmp_notification_with_http_info(self, snmp_notification, **kwargs):  # noqa: E501
        """Update snmp-notification by ID  # noqa: E501

        Update operation of resource: snmp-notification  # 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_healthbot_ingest_snmp_notification_with_http_info(snmp_notification, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SnmpNotificationSchema snmp_notification: snmp_notification body object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['snmp_notification', 'x_iam_token']  # 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_healthbot_ingest_snmp_notification" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'snmp_notification' is set
        if ('snmp_notification' not in params or
                params['snmp_notification'] is None):
            raise ValueError("Missing the required parameter `snmp_notification` when calling `update_healthbot_ingest_snmp_notification`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'snmp_notification' in params:
            body_params = params['snmp_notification']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id(self, name, usm_user, **kwargs):  # noqa: E501
        """Update SNMPv3 user by UserName(ID)  # noqa: E501

        Update operation of resource: snmp v3 usm user  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id(name, usm_user, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: User Name (required)
        :param Snmpv3UsmUserSchema usm_user: snmp_v3_usm user object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, usm_user, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, usm_user, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(self, name, usm_user, **kwargs):  # noqa: E501
        """Update SNMPv3 user by UserName(ID)  # noqa: E501

        Update operation of resource: snmp v3 usm user  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id_with_http_info(name, usm_user, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: User Name (required)
        :param Snmpv3UsmUserSchema usm_user: snmp_v3_usm user object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'usm_user', 'x_iam_token']  # 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_healthbot_ingest_snmp_notification_v3_usm_user_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_snmp_notification_v3_usm_user_by_id`")  # noqa: E501
        # verify the required parameter 'usm_user' is set
        if ('usm_user' not in params or
                params['usm_user'] is None):
            raise ValueError("Missing the required parameter `usm_user` when calling `update_healthbot_ingest_snmp_notification_v3_usm_user_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'usm_user' in params:
            body_params = params['usm_user']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/snmp-notification/v3/usm/user/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_syslog_header_pattern_by_id(self, name, pattern, **kwargs):  # noqa: E501
        """Update pattern by ID  # noqa: E501

        Update operation of resource: header-pattern  # 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_healthbot_ingest_syslog_header_pattern_by_id(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param HeaderPatternSchema pattern: header_patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(self, name, pattern, **kwargs):  # noqa: E501
        """Update pattern by ID  # noqa: E501

        Update operation of resource: header-pattern  # 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_healthbot_ingest_syslog_header_pattern_by_id_with_http_info(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param HeaderPatternSchema pattern: header_patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern', 'x_iam_token']  # 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_healthbot_ingest_syslog_header_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_syslog_header_pattern_by_id`")  # noqa: E501
        # verify the required parameter 'pattern' is set
        if ('pattern' not in params or
                params['pattern'] is None):
            raise ValueError("Missing the required parameter `pattern` when calling `update_healthbot_ingest_syslog_header_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern' in params:
            body_params = params['pattern']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/header-pattern/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_tagging_profile_by_id(self, name, tagging_profile, **kwargs):  # noqa: E501
        """Update tagging-profile by ID  # noqa: E501

        Update operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profile_by_id(name, tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param TaggingProfileSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_tagging_profile_by_id_with_http_info(name, tagging_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_tagging_profile_by_id_with_http_info(name, tagging_profile, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_tagging_profile_by_id_with_http_info(self, name, tagging_profile, **kwargs):  # noqa: E501
        """Update tagging-profile by ID  # noqa: E501

        Update operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profile_by_id_with_http_info(name, tagging_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: ID of name (required)
        :param TaggingProfileSchema tagging_profile: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'tagging_profile', 'x_iam_token']  # 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_healthbot_ingest_tagging_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_healthbot_ingest_tagging_profile_by_id`")  # noqa: E501
        # verify the required parameter 'tagging_profile' is set
        if ('tagging_profile' not in params or
                params['tagging_profile'] is None):
            raise ValueError("Missing the required parameter `tagging_profile` when calling `update_healthbot_ingest_tagging_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tagging_profile' in params:
            body_params = params['tagging_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/data-enrichment/tagging-profile/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_ingest_tagging_profiles(self, tagging_profiles, **kwargs):  # noqa: E501
        """Update tagging-profile by ID  # noqa: E501

        Update operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profiles(tagging_profiles, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaggingProfilesSchema tagging_profiles: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_ingest_tagging_profiles_with_http_info(tagging_profiles, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_ingest_tagging_profiles_with_http_info(tagging_profiles, **kwargs)  # noqa: E501
            return data

    def update_healthbot_ingest_tagging_profiles_with_http_info(self, tagging_profiles, **kwargs):  # noqa: E501
        """Update tagging-profile by ID  # noqa: E501

        Update operation of resource: tagging-profile  # 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_healthbot_ingest_tagging_profiles_with_http_info(tagging_profiles, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TaggingProfilesSchema tagging_profiles: tagging_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['tagging_profiles', 'x_iam_token']  # 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_healthbot_ingest_tagging_profiles" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'tagging_profiles' is set
        if ('tagging_profiles' not in params or
                params['tagging_profiles'] is None):
            raise ValueError("Missing the required parameter `tagging_profiles` when calling `update_healthbot_ingest_tagging_profiles`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'tagging_profiles' in params:
            body_params = params['tagging_profiles']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/data-enrichment/tagging-profiles/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # 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_healthbot_organization_organization_by_id(self, organization_name, organization, **kwargs):  # noqa: E501
        """Update organization by ID  # noqa: E501

        Update operation of resource: organization  # 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_healthbot_organization_organization_by_id(organization_name, organization, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str organization_name: ID of organization-name (required)
        :param OrganizationSchema organization: organizationbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_organization_organization_by_id_with_http_info(organization_name, organization, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_organization_organization_by_id_with_http_info(organization_name, organization, **kwargs)  # noqa: E501
            return data

    def update_healthbot_organization_organization_by_id_with_http_info(self, organization_name, organization, **kwargs):  # noqa: E501
        """Update organization by ID  # noqa: E501

        Update operation of resource: organization  # 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_healthbot_organization_organization_by_id_with_http_info(organization_name, organization, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str organization_name: ID of organization-name (required)
        :param OrganizationSchema organization: organizationbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['organization_name', 'organization', 'x_iam_token']  # 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_healthbot_organization_organization_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'organization_name' is set
        if ('organization_name' not in params or
                params['organization_name'] is None):
            raise ValueError("Missing the required parameter `organization_name` when calling `update_healthbot_organization_organization_by_id`")  # noqa: E501
        # verify the required parameter 'organization' is set
        if ('organization' not in params or
                params['organization'] is None):
            raise ValueError("Missing the required parameter `organization` when calling `update_healthbot_organization_organization_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'organization_name' in params:
            path_params['organization_name'] = params['organization_name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'organization' in params:
            body_params = params['organization']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/organization/{organization_name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id(self, profile_id, field_profile, **kwargs):  # noqa: E501
        """Update field-profile by ID  # noqa: E501

        Update operation of resource: field-profile  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id(profile_id, field_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str profile_id: ID of profile-id (required)
        :param RollupSummarizationSchema field_profile: field_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, field_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, field_profile, **kwargs)  # noqa: E501
            return data

    def update_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(self, profile_id, field_profile, **kwargs):  # noqa: E501
        """Update field-profile by ID  # noqa: E501

        Update operation of resource: field-profile  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id_with_http_info(profile_id, field_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str profile_id: ID of profile-id (required)
        :param RollupSummarizationSchema field_profile: field_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['profile_id', 'field_profile', 'x_iam_token']  # 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_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'profile_id' is set
        if ('profile_id' not in params or
                params['profile_id'] is None):
            raise ValueError("Missing the required parameter `profile_id` when calling `update_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id`")  # noqa: E501
        # verify the required parameter 'field_profile' is set
        if ('field_profile' not in params or
                params['field_profile'] is None):
            raise ValueError("Missing the required parameter `field_profile` when calling `update_healthbot_profile_rollup_summarization_field_profile_field_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'profile_id' in params:
            path_params['profile_id'] = params['profile_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'field_profile' in params:
            body_params = params['field_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/rollup-summarization/field-profile/{profile_id}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_system_time_series_database_time_series_database_by_id(self, time_series_database, **kwargs):  # noqa: E501
        """Update time-series-database by ID  # noqa: E501

        Update operation of resource: time-series-database  # 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_healthbot_system_time_series_database_time_series_database_by_id(time_series_database, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TsdbSchema time_series_database: time_series_databasebody object (required)
        :param bool force_tsdb: force update tsdb when force is set to True
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(time_series_database, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(time_series_database, **kwargs)  # noqa: E501
            return data

    def update_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(self, time_series_database, **kwargs):  # noqa: E501
        """Update time-series-database by ID  # noqa: E501

        Update operation of resource: time-series-database  # 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_healthbot_system_time_series_database_time_series_database_by_id_with_http_info(time_series_database, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TsdbSchema time_series_database: time_series_databasebody object (required)
        :param bool force_tsdb: force update tsdb when force is set to True
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['time_series_database', 'force_tsdb']  # 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_healthbot_system_time_series_database_time_series_database_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'time_series_database' is set
        if ('time_series_database' not in params or
                params['time_series_database'] is None):
            raise ValueError("Missing the required parameter `time_series_database` when calling `update_healthbot_system_time_series_database_time_series_database_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'force_tsdb' in params:
            query_params.append(('force_tsdb', params['force_tsdb']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'time_series_database' in params:
            body_params = params['time_series_database']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/system/tsdb/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_healthbot_system_trigger_action(self, trigger_action, **kwargs):  # noqa: E501
        """Update trigger-action  # noqa: E501

        Update operation of resource: trigger-action  # 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_healthbot_system_trigger_action(trigger_action, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TriggerActionSchema trigger_action: trigger_action object (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_healthbot_system_trigger_action_with_http_info(trigger_action, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_system_trigger_action_with_http_info(trigger_action, **kwargs)  # noqa: E501
            return data

    def update_healthbot_system_trigger_action_with_http_info(self, trigger_action, **kwargs):  # noqa: E501
        """Update trigger-action  # noqa: E501

        Update operation of resource: trigger-action  # 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_healthbot_system_trigger_action_with_http_info(trigger_action, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TriggerActionSchema trigger_action: trigger_action object (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['trigger_action']  # 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_healthbot_system_trigger_action" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'trigger_action' is set
        if ('trigger_action' not in params or
                params['trigger_action'] is None):
            raise ValueError("Missing the required parameter `trigger_action` when calling `update_healthbot_system_trigger_action`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'trigger_action' in params:
            body_params = params['trigger_action']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/system/trigger_action/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest(self, ingest_settings, **kwargs):  # noqa: E501
        """Update ingest by ID  # noqa: E501

        Update operation of resource: ingest  # 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_iceberg_ingest(ingest_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IngestSettingsSchema ingest_settings: ingest_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_with_http_info(ingest_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_with_http_info(ingest_settings, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_with_http_info(self, ingest_settings, **kwargs):  # noqa: E501
        """Update ingest by ID  # noqa: E501

        Update operation of resource: ingest  # 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_iceberg_ingest_with_http_info(ingest_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IngestSettingsSchema ingest_settings: ingest_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['ingest_settings', 'x_iam_token']  # 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_iceberg_ingest" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'ingest_settings' is set
        if ('ingest_settings' not in params or
                params['ingest_settings'] is None):
            raise ValueError("Missing the required parameter `ingest_settings` when calling `update_iceberg_ingest`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ingest_settings' in params:
            body_params = params['ingest_settings']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_flow(self, flow, **kwargs):  # noqa: E501
        """Update flow by ID  # noqa: E501

        Update operation of resource: flow  # 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_iceberg_ingest_flow(flow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FlowSchema flow: flowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_flow_with_http_info(flow, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_flow_with_http_info(flow, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_flow_with_http_info(self, flow, **kwargs):  # noqa: E501
        """Update flow by ID  # noqa: E501

        Update operation of resource: flow  # 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_iceberg_ingest_flow_with_http_info(flow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FlowSchema flow: flowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['flow', 'x_iam_token']  # 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_iceberg_ingest_flow" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'flow' is set
        if ('flow' not in params or
                params['flow'] is None):
            raise ValueError("Missing the required parameter `flow` when calling `update_iceberg_ingest_flow`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'flow' in params:
            body_params = params['flow']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_flow_template_by_id(self, name, template, **kwargs):  # noqa: E501
        """Update template by ID  # noqa: E501

        Update operation of resource: template  # 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_iceberg_ingest_flow_template_by_id(name, template, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param TemplateSchema template: templatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_flow_template_by_id_with_http_info(name, template, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_flow_template_by_id_with_http_info(name, template, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_flow_template_by_id_with_http_info(self, name, template, **kwargs):  # noqa: E501
        """Update template by ID  # noqa: E501

        Update operation of resource: template  # 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_iceberg_ingest_flow_template_by_id_with_http_info(name, template, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param TemplateSchema template: templatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'template', 'x_iam_token']  # 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_iceberg_ingest_flow_template_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_ingest_flow_template_by_id`")  # noqa: E501
        # verify the required parameter 'template' is set
        if ('template' not in params or
                params['template'] is None):
            raise ValueError("Missing the required parameter `template` when calling `update_iceberg_ingest_flow_template_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'template' in params:
            body_params = params['template']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/flow/template/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_native_gpb(self, native_gpb, **kwargs):  # noqa: E501
        """Update native-gpb by ID  # noqa: E501

        Update operation of resource: native-gpb  # 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_iceberg_ingest_native_gpb(native_gpb, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NativeGpbSchema native_gpb: native_gpbbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_native_gpb_with_http_info(native_gpb, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_native_gpb_with_http_info(native_gpb, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_native_gpb_with_http_info(self, native_gpb, **kwargs):  # noqa: E501
        """Update native-gpb by ID  # noqa: E501

        Update operation of resource: native-gpb  # 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_iceberg_ingest_native_gpb_with_http_info(native_gpb, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NativeGpbSchema native_gpb: native_gpbbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['native_gpb', 'x_iam_token']  # 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_iceberg_ingest_native_gpb" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'native_gpb' is set
        if ('native_gpb' not in params or
                params['native_gpb'] is None):
            raise ValueError("Missing the required parameter `native_gpb` when calling `update_iceberg_ingest_native_gpb`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'native_gpb' in params:
            body_params = params['native_gpb']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/native-gpb/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings(self, ingest_settings, **kwargs):  # noqa: E501
        """Update ingest-settings by ID  # noqa: E501

        Update operation of resource: ingest-settings  # 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_iceberg_ingest_settings(ingest_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IngestSettingsSchema ingest_settings: ingest_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_settings_with_http_info(ingest_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_settings_with_http_info(ingest_settings, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_settings_with_http_info(self, ingest_settings, **kwargs):  # noqa: E501
        """Update ingest-settings by ID  # noqa: E501

        Update operation of resource: ingest-settings  # 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_iceberg_ingest_settings_with_http_info(ingest_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IngestSettingsSchema ingest_settings: ingest_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['ingest_settings', 'x_iam_token']  # 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_iceberg_ingest_settings" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'ingest_settings' is set
        if ('ingest_settings' not in params or
                params['ingest_settings'] is None):
            raise ValueError("Missing the required parameter `ingest_settings` when calling `update_iceberg_ingest_settings`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ingest_settings' in params:
            body_params = params['ingest_settings']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_flow(self, flow, **kwargs):  # noqa: E501
        """Update flow by ID  # noqa: E501

        Update operation of resource: flow  # 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_iceberg_ingest_settings_flow(flow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FlowSchema flow: flowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_settings_flow_with_http_info(flow, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_settings_flow_with_http_info(flow, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_settings_flow_with_http_info(self, flow, **kwargs):  # noqa: E501
        """Update flow by ID  # noqa: E501

        Update operation of resource: flow  # 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_iceberg_ingest_settings_flow_with_http_info(flow, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param FlowSchema flow: flowbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['flow', 'x_iam_token']  # 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_iceberg_ingest_settings_flow" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'flow' is set
        if ('flow' not in params or
                params['flow'] is None):
            raise ValueError("Missing the required parameter `flow` when calling `update_iceberg_ingest_settings_flow`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'flow' in params:
            body_params = params['flow']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_flow_template_by_id(self, name, template, **kwargs):  # noqa: E501
        """Update template by ID  # noqa: E501

        Update operation of resource: template  # 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_iceberg_ingest_settings_flow_template_by_id(name, template, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param TemplateSchema template: templatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, template, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, template, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_settings_flow_template_by_id_with_http_info(self, name, template, **kwargs):  # noqa: E501
        """Update template by ID  # noqa: E501

        Update operation of resource: template  # 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_iceberg_ingest_settings_flow_template_by_id_with_http_info(name, template, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of template (required)
        :param TemplateSchema template: templatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'template', 'x_iam_token']  # 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_iceberg_ingest_settings_flow_template_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_ingest_settings_flow_template_by_id`")  # noqa: E501
        # verify the required parameter 'template' is set
        if ('template' not in params or
                params['template'] is None):
            raise ValueError("Missing the required parameter `template` when calling `update_iceberg_ingest_settings_flow_template_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'template' in params:
            body_params = params['template']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/flow/template/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog(self, syslog, **kwargs):  # noqa: E501
        """Update syslog by ID  # noqa: E501

        Update operation of resource: syslog  # 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_iceberg_ingest_settings_syslog(syslog, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SyslogSchema syslog: syslogbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_settings_syslog_with_http_info(syslog, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_settings_syslog_with_http_info(syslog, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_settings_syslog_with_http_info(self, syslog, **kwargs):  # noqa: E501
        """Update syslog by ID  # noqa: E501

        Update operation of resource: syslog  # 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_iceberg_ingest_settings_syslog_with_http_info(syslog, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SyslogSchema syslog: syslogbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['syslog', 'x_iam_token']  # 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_iceberg_ingest_settings_syslog" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'syslog' is set
        if ('syslog' not in params or
                params['syslog'] is None):
            raise ValueError("Missing the required parameter `syslog` when calling `update_iceberg_ingest_settings_syslog`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'syslog' in params:
            body_params = params['syslog']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog_pattern_by_id(self, name, pattern, **kwargs):  # noqa: E501
        """Update pattern by ID  # noqa: E501

        Update operation of resource: pattern  # 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_iceberg_ingest_settings_syslog_pattern_by_id(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param PatternSchema pattern: patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(self, name, pattern, **kwargs):  # noqa: E501
        """Update pattern by ID  # noqa: E501

        Update operation of resource: pattern  # 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_iceberg_ingest_settings_syslog_pattern_by_id_with_http_info(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param PatternSchema pattern: patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern', 'x_iam_token']  # 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_iceberg_ingest_settings_syslog_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_ingest_settings_syslog_pattern_by_id`")  # noqa: E501
        # verify the required parameter 'pattern' is set
        if ('pattern' not in params or
                params['pattern'] is None):
            raise ValueError("Missing the required parameter `pattern` when calling `update_iceberg_ingest_settings_syslog_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern' in params:
            body_params = params['pattern']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id(self, name, pattern_set, **kwargs):  # noqa: E501
        """Update pattern-set by ID  # noqa: E501

        Update operation of resource: pattern-set  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id(name, pattern_set, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param PatternSetSchema pattern_set: pattern_setbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, pattern_set, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, pattern_set, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(self, name, pattern_set, **kwargs):  # noqa: E501
        """Update pattern-set by ID  # noqa: E501

        Update operation of resource: pattern-set  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id_with_http_info(name, pattern_set, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param PatternSetSchema pattern_set: pattern_setbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern_set', 'x_iam_token']  # 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_iceberg_ingest_settings_syslog_pattern_set_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_ingest_settings_syslog_pattern_set_by_id`")  # noqa: E501
        # verify the required parameter 'pattern_set' is set
        if ('pattern_set' not in params or
                params['pattern_set'] is None):
            raise ValueError("Missing the required parameter `pattern_set` when calling `update_iceberg_ingest_settings_syslog_pattern_set_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern_set' in params:
            body_params = params['pattern_set']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest-settings/syslog/pattern-set/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog(self, syslog, **kwargs):  # noqa: E501
        """Update syslog by ID  # noqa: E501

        Update operation of resource: syslog  # 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_iceberg_ingest_syslog(syslog, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SyslogSchema syslog: syslogbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_syslog_with_http_info(syslog, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_syslog_with_http_info(syslog, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_syslog_with_http_info(self, syslog, **kwargs):  # noqa: E501
        """Update syslog by ID  # noqa: E501

        Update operation of resource: syslog  # 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_iceberg_ingest_syslog_with_http_info(syslog, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SyslogSchema syslog: syslogbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['syslog', 'x_iam_token']  # 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_iceberg_ingest_syslog" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'syslog' is set
        if ('syslog' not in params or
                params['syslog'] is None):
            raise ValueError("Missing the required parameter `syslog` when calling `update_iceberg_ingest_syslog`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'syslog' in params:
            body_params = params['syslog']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog_pattern_by_id(self, name, pattern, **kwargs):  # noqa: E501
        """Update pattern by ID  # noqa: E501

        Update operation of resource: pattern  # 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_iceberg_ingest_syslog_pattern_by_id(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param PatternSchema pattern: patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, pattern, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_syslog_pattern_by_id_with_http_info(self, name, pattern, **kwargs):  # noqa: E501
        """Update pattern by ID  # noqa: E501

        Update operation of resource: pattern  # 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_iceberg_ingest_syslog_pattern_by_id_with_http_info(name, pattern, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern (required)
        :param PatternSchema pattern: patternbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern', 'x_iam_token']  # 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_iceberg_ingest_syslog_pattern_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_ingest_syslog_pattern_by_id`")  # noqa: E501
        # verify the required parameter 'pattern' is set
        if ('pattern' not in params or
                params['pattern'] is None):
            raise ValueError("Missing the required parameter `pattern` when calling `update_iceberg_ingest_syslog_pattern_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern' in params:
            body_params = params['pattern']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_ingest_syslog_pattern_set_by_id(self, name, pattern_set, **kwargs):  # noqa: E501
        """Update pattern-set by ID  # noqa: E501

        Update operation of resource: pattern-set  # 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_iceberg_ingest_syslog_pattern_set_by_id(name, pattern_set, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param PatternSetSchema pattern_set: pattern_setbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, pattern_set, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, pattern_set, **kwargs)  # noqa: E501
            return data

    def update_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(self, name, pattern_set, **kwargs):  # noqa: E501
        """Update pattern-set by ID  # noqa: E501

        Update operation of resource: pattern-set  # 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_iceberg_ingest_syslog_pattern_set_by_id_with_http_info(name, pattern_set, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of pattern-set (required)
        :param PatternSetSchema pattern_set: pattern_setbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'pattern_set', 'x_iam_token']  # 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_iceberg_ingest_syslog_pattern_set_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_ingest_syslog_pattern_set_by_id`")  # noqa: E501
        # verify the required parameter 'pattern_set' is set
        if ('pattern_set' not in params or
                params['pattern_set'] is None):
            raise ValueError("Missing the required parameter `pattern_set` when calling `update_iceberg_ingest_syslog_pattern_set_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'pattern_set' in params:
            body_params = params['pattern_set']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/ingest/syslog/pattern-set/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_data_summarization_raw_by_id(self, name, raw_data_summarization, **kwargs):  # noqa: E501
        """Update raw-data-summarization by ID  # noqa: E501

        Update operation of resource: raw-data-summarization  # 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_iceberg_profile_data_summarization_raw_by_id(name, raw_data_summarization, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of raw-data-summarization (required)
        :param RawSchema raw_data_summarization: raw_data_summarizationbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, raw_data_summarization, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, raw_data_summarization, **kwargs)  # noqa: E501
            return data

    def update_iceberg_profile_data_summarization_raw_by_id_with_http_info(self, name, raw_data_summarization, **kwargs):  # noqa: E501
        """Update raw-data-summarization by ID  # noqa: E501

        Update operation of resource: raw-data-summarization  # 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_iceberg_profile_data_summarization_raw_by_id_with_http_info(name, raw_data_summarization, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of raw-data-summarization (required)
        :param RawSchema raw_data_summarization: raw_data_summarizationbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'raw_data_summarization', 'x_iam_token']  # 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_iceberg_profile_data_summarization_raw_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_profile_data_summarization_raw_by_id`")  # noqa: E501
        # verify the required parameter 'raw_data_summarization' is set
        if ('raw_data_summarization' not in params or
                params['raw_data_summarization'] is None):
            raise ValueError("Missing the required parameter `raw_data_summarization` when calling `update_iceberg_profile_data_summarization_raw_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'raw_data_summarization' in params:
            body_params = params['raw_data_summarization']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/data-summarization/raw/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_ca_profile_by_id(self, name, ca_profile, **kwargs):  # noqa: E501
        """Update ca-profile by ID  # noqa: E501

        Update operation of resource: ca-profile  # 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_iceberg_profile_security_ca_profile_by_id(name, ca_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ca-profile (required)
        :param CaProfileSchema ca_profile: ca_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_profile_security_ca_profile_by_id_with_http_info(name, ca_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_profile_security_ca_profile_by_id_with_http_info(name, ca_profile, **kwargs)  # noqa: E501
            return data

    def update_iceberg_profile_security_ca_profile_by_id_with_http_info(self, name, ca_profile, **kwargs):  # noqa: E501
        """Update ca-profile by ID  # noqa: E501

        Update operation of resource: ca-profile  # 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_iceberg_profile_security_ca_profile_by_id_with_http_info(name, ca_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ca-profile (required)
        :param CaProfileSchema ca_profile: ca_profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'ca_profile', 'x_iam_token']  # 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_iceberg_profile_security_ca_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_profile_security_ca_profile_by_id`")  # noqa: E501
        # verify the required parameter 'ca_profile' is set
        if ('ca_profile' not in params or
                params['ca_profile'] is None):
            raise ValueError("Missing the required parameter `ca_profile` when calling `update_iceberg_profile_security_ca_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ca_profile' in params:
            body_params = params['ca_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ca-profile/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_local_certificate_by_id(self, name, local_certificate, **kwargs):  # noqa: E501
        """Update local-certificate by ID  # noqa: E501

        Update operation of resource: local-certificate  # 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_iceberg_profile_security_local_certificate_by_id(name, local_certificate, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of local-certificate (required)
        :param LocalCertificateSchema local_certificate: local_certificatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_profile_security_local_certificate_by_id_with_http_info(name, local_certificate, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_profile_security_local_certificate_by_id_with_http_info(name, local_certificate, **kwargs)  # noqa: E501
            return data

    def update_iceberg_profile_security_local_certificate_by_id_with_http_info(self, name, local_certificate, **kwargs):  # noqa: E501
        """Update local-certificate by ID  # noqa: E501

        Update operation of resource: local-certificate  # 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_iceberg_profile_security_local_certificate_by_id_with_http_info(name, local_certificate, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of local-certificate (required)
        :param LocalCertificateSchema local_certificate: local_certificatebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'local_certificate', 'x_iam_token']  # 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_iceberg_profile_security_local_certificate_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_profile_security_local_certificate_by_id`")  # noqa: E501
        # verify the required parameter 'local_certificate' is set
        if ('local_certificate' not in params or
                params['local_certificate'] is None):
            raise ValueError("Missing the required parameter `local_certificate` when calling `update_iceberg_profile_security_local_certificate_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'local_certificate' in params:
            body_params = params['local_certificate']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/local-certificate/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profile_security_ssh_key_profile_by_id(self, name, ssh_key_profile, **kwargs):  # noqa: E501
        """Update ssh-key-profile by ID  # noqa: E501

        Update operation of resource: ssh-key-profile  # 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_iceberg_profile_security_ssh_key_profile_by_id(name, ssh_key_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ssh-key-profile (required)
        :param SshKeyProfileSchema ssh_key_profile: ssh_key_profilebody object (required)
        :param str authorization: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, ssh_key_profile, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, ssh_key_profile, **kwargs)  # noqa: E501
            return data

    def update_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(self, name, ssh_key_profile, **kwargs):  # noqa: E501
        """Update ssh-key-profile by ID  # noqa: E501

        Update operation of resource: ssh-key-profile  # 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_iceberg_profile_security_ssh_key_profile_by_id_with_http_info(name, ssh_key_profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of ssh-key-profile (required)
        :param SshKeyProfileSchema ssh_key_profile: ssh_key_profilebody object (required)
        :param str authorization: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['name', 'ssh_key_profile', 'authorization']  # 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_iceberg_profile_security_ssh_key_profile_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'name' is set
        if ('name' not in params or
                params['name'] is None):
            raise ValueError("Missing the required parameter `name` when calling `update_iceberg_profile_security_ssh_key_profile_by_id`")  # noqa: E501
        # verify the required parameter 'ssh_key_profile' is set
        if ('ssh_key_profile' not in params or
                params['ssh_key_profile'] is None):
            raise ValueError("Missing the required parameter `ssh_key_profile` when calling `update_iceberg_profile_security_ssh_key_profile_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'name' in params:
            path_params['name'] = params['name']  # noqa: E501

        query_params = []

        header_params = {}
        if 'authorization' in params:
            header_params['Authorization'] = params['authorization']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ssh_key_profile' in params:
            body_params = params['ssh_key_profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profile/security/ssh-key-profile/{name}/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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_iceberg_profiles(self, profile, **kwargs):  # noqa: E501
        """Update profile by ID  # noqa: E501

        Update entire profile configuration.  # 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_iceberg_profiles(profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ProfilesSchema profile: profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_iceberg_profiles_with_http_info(profile, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_profiles_with_http_info(profile, **kwargs)  # noqa: E501
            return data

    def update_iceberg_profiles_with_http_info(self, profile, **kwargs):  # noqa: E501
        """Update profile by ID  # noqa: E501

        Update entire profile configuration.  # 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_iceberg_profiles_with_http_info(profile, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ProfilesSchema profile: profilebody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['profile', 'x_iam_token']  # 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_iceberg_profiles" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'profile' is set
        if ('profile' not in params or
                params['profile'] is None):
            raise ValueError("Missing the required parameter `profile` when calling `update_iceberg_profiles`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_iam_token' in params:
            header_params['x-iam-token'] = params['x_iam_token']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'profile' in params:
            body_params = params['profile']
        # 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 = []  # noqa: E501

        return self.api_client.call_api(
            '/config/profiles/', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # 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)
