# 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 ConfigurationApi(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 check_device_group_unsaved_configuration(self, device_group_name, **kwargs):  # noqa: E501
        """Check if the un-committed configuration of the given device group is correct  # noqa: E501

        Checks if the un-committed configuration of a device-group is correct. The un-committed changes are merged with the committed configuration and the complete configuration required for the supplied device-group is validated.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_device_group_unsaved_configuration(device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: Name of device group (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.check_device_group_unsaved_configuration_with_http_info(device_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.check_device_group_unsaved_configuration_with_http_info(device_group_name, **kwargs)  # noqa: E501
            return data

    def check_device_group_unsaved_configuration_with_http_info(self, device_group_name, **kwargs):  # noqa: E501
        """Check if the un-committed configuration of the given device group is correct  # noqa: E501

        Checks if the un-committed configuration of a device-group is correct. The un-committed changes are merged with the committed configuration and the complete configuration required for the supplied device-group is validated.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_device_group_unsaved_configuration_with_http_info(device_group_name, async_req=True)
        >>> result = thread.get()

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

        all_params = ['device_group_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 check_device_group_unsaved_configuration" % 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 `check_device_group_unsaved_configuration`")  # 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 = []

        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/check/device-group/{device_group_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 check_network_group_unsaved_configuration(self, network_group_name, **kwargs):  # noqa: E501
        """Check if the unsaved configuration of the given network group is correct.  # noqa: E501

        Checks if the un-committed configuration of a network-group is correct. The un-committed changes are merged with the committed configuration and the complete configuration required for the supplied network-group is validated.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_network_group_unsaved_configuration(network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: Name of network group (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.check_network_group_unsaved_configuration_with_http_info(network_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.check_network_group_unsaved_configuration_with_http_info(network_group_name, **kwargs)  # noqa: E501
            return data

    def check_network_group_unsaved_configuration_with_http_info(self, network_group_name, **kwargs):  # noqa: E501
        """Check if the unsaved configuration of the given network group is correct.  # noqa: E501

        Checks if the un-committed configuration of a network-group is correct. The un-committed changes are merged with the committed configuration and the complete configuration required for the supplied network-group is validated.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_network_group_unsaved_configuration_with_http_info(network_group_name, async_req=True)
        >>> result = thread.get()

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

        all_params = ['network_group_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 check_network_group_unsaved_configuration" % 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 `check_network_group_unsaved_configuration`")  # 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 = []

        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/check/network-group/{network_group_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 commit_unsaved_configuration(self, **kwargs):  # noqa: E501
        """Commit unsaved configuration.  # noqa: E501

        Commit the configuration in configuration database. Services of all the affected groups are started or restarted. If there is an error in the configuration, changes would not be saved into the database. If there is some system error, changes would be saved into the 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.commit_unsaved_configuration(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool sync: Boolean variable is set to false allow the commit to go asynchronously, default value is true which means commit will go synchronously
        :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.commit_unsaved_configuration_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.commit_unsaved_configuration_with_http_info(**kwargs)  # noqa: E501
            return data

    def commit_unsaved_configuration_with_http_info(self, **kwargs):  # noqa: E501
        """Commit unsaved configuration.  # noqa: E501

        Commit the configuration in configuration database. Services of all the affected groups are started or restarted. If there is an error in the configuration, changes would not be saved into the database. If there is some system error, changes would be saved into the 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.commit_unsaved_configuration_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool sync: Boolean variable is set to false allow the commit to go asynchronously, default value is true which means commit will go synchronously
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'sync']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method commit_unsaved_configuration" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'sync' in params:
            query_params.append(('sync', params['sync']))  # 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/', '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_organizations_organizations(self, organizations, **kwargs):  # noqa: E501
        """Update or create multiple organizations.  # noqa: E501

        Create/Update multiple organizations. The new content for the existing organizations updates the existing content and the new organizations are created.  # 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_organizations_organizations(organizations, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param OrganizationsSchema organizations: organizations 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_organizations_organizations_with_http_info(organizations, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_organizations_organizations_with_http_info(organizations, **kwargs)  # noqa: E501
            return data

    def create_healthbot_organizations_organizations_with_http_info(self, organizations, **kwargs):  # noqa: E501
        """Update or create multiple organizations.  # noqa: E501

        Create/Update multiple organizations. The new content for the existing organizations updates the existing content and the new organizations are created.  # 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_organizations_organizations_with_http_info(organizations, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param OrganizationsSchema organizations: organizations 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 = ['organizations', '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_organizations_organizations" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'organizations' is set
        if ('organizations' not in params or
                params['organizations'] is None):
            raise ValueError("Missing the required parameter `organizations` when calling `create_healthbot_organizations_organizations`")  # 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 'organizations' in params:
            body_params = params['organizations']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_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/organizations/', '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_topic_resource_resource_by_id(self, topic_name, resource_name, resource, **kwargs):  # noqa: E501
        """Update or create a resource  # noqa: E501

        Create/Update a resource by `resource-name`. The `resource-name` specified in URL and the request body must match. If the resource already exists then, the existing resource's configuration will be updated with the new content  # 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_topic_resource_resource_by_id(topic_name, resource_name, resource, 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 ResourceSchema resource: resourcebody 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_healthbot_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, resource, **kwargs)  # noqa: E501
        else:
            (data) = self.create_healthbot_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, resource, **kwargs)  # noqa: E501
            return data

    def create_healthbot_topic_resource_resource_by_id_with_http_info(self, topic_name, resource_name, resource, **kwargs):  # noqa: E501
        """Update or create a resource  # noqa: E501

        Create/Update a resource by `resource-name`. The `resource-name` specified in URL and the request body must match. If the resource already exists then, the existing resource's configuration will be updated with the new content  # 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_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, resource, 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 ResourceSchema resource: resourcebody object (required)
        :param str authorization: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['topic_name', 'resource_name', 'resource', '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_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 `create_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 `create_healthbot_topic_resource_resource_by_id`")  # noqa: E501
        # verify the required parameter 'resource' is set
        if ('resource' not in params or
                params['resource'] is None):
            raise ValueError("Missing the required parameter `resource` when calling `create_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 = []

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

        form_params = []
        local_var_files = {}

        body_params = None
        if 'resource' in params:
            body_params = params['resource']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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}/', '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_device_device_by_id(self, device_id, device, **kwargs):  # noqa: E501
        """Update or create a device.  # noqa: E501

        Create/Update a device by `device-id`. The `device-id` specified in URL and the request body must match. If the device already exists then, old content will be updated with the new content.  # 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_device_device_by_id(device_id, device, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_id: ID of device-id (required)
        :param DeviceSchema device: devicebody 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_device_device_by_id_with_http_info(device_id, device, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_device_device_by_id_with_http_info(device_id, device, **kwargs)  # noqa: E501
            return data

    def create_iceberg_device_device_by_id_with_http_info(self, device_id, device, **kwargs):  # noqa: E501
        """Update or create a device.  # noqa: E501

        Create/Update a device by `device-id`. The `device-id` specified in URL and the request body must match. If the device already exists then, old content will be updated with the new content.  # 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_device_device_by_id_with_http_info(device_id, device, async_req=True)
        >>> result = thread.get()

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

        all_params = ['device_id', 'device', '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_device_device_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 `create_iceberg_device_device_by_id`")  # noqa: E501
        # verify the required parameter 'device' is set
        if ('device' not in params or
                params['device'] is None):
            raise ValueError("Missing the required parameter `device` when calling `create_iceberg_device_device_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'device_id' in params:
            path_params['device_id'] = params['device_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 'device' in params:
            body_params = params['device']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/device/{device_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_iceberg_device_group_device_group_by_id(self, device_group_name, device_group, **kwargs):  # noqa: E501
        """Update or create a device-group.  # noqa: E501

        Create/Update a device-group by `device-group-name`. The `device-group-name` specified in URL and the request body must match. If the device-group already exists then, old content will be updated with the new content  # 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_device_group_device_group_by_id(device_group_name, device_group, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: ID of device-group-name (required)
        :param DeviceGroupSchema device_group: device_groupbody 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_device_group_device_group_by_id_with_http_info(device_group_name, device_group, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_device_group_device_group_by_id_with_http_info(device_group_name, device_group, **kwargs)  # noqa: E501
            return data

    def create_iceberg_device_group_device_group_by_id_with_http_info(self, device_group_name, device_group, **kwargs):  # noqa: E501
        """Update or create a device-group.  # noqa: E501

        Create/Update a device-group by `device-group-name`. The `device-group-name` specified in URL and the request body must match. If the device-group already exists then, old content will be updated with the new content  # 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_device_group_device_group_by_id_with_http_info(device_group_name, device_group, async_req=True)
        >>> result = thread.get()

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

        all_params = ['device_group_name', 'device_group', '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_device_group_device_group_by_id" % 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 `create_iceberg_device_group_device_group_by_id`")  # noqa: E501
        # verify the required parameter 'device_group' is set
        if ('device_group' not in params or
                params['device_group'] is None):
            raise ValueError("Missing the required parameter `device_group` when calling `create_iceberg_device_group_device_group_by_id`")  # 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 = []

        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 'device_group' in params:
            body_params = params['device_group']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/device-group/{device_group_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_device_groups_device_groups_by_id(self, device_groups, **kwargs):  # noqa: E501
        """Update or create multiple device-groups.  # noqa: E501

        Create/Update multiple device-groups. The new content for the existing device-groups updates the existing content and new device-groups are created.  # 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_device_groups_device_groups_by_id(device_groups, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeviceGroupsSchema device_groups: device-groupsbody 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_device_groups_device_groups_by_id_with_http_info(device_groups, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_device_groups_device_groups_by_id_with_http_info(device_groups, **kwargs)  # noqa: E501
            return data

    def create_iceberg_device_groups_device_groups_by_id_with_http_info(self, device_groups, **kwargs):  # noqa: E501
        """Update or create multiple device-groups.  # noqa: E501

        Create/Update multiple device-groups. The new content for the existing device-groups updates the existing content and new device-groups are created.  # 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_device_groups_device_groups_by_id_with_http_info(device_groups, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeviceGroupsSchema device_groups: device-groupsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['device_groups', '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_device_groups_device_groups_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'device_groups' is set
        if ('device_groups' not in params or
                params['device_groups'] is None):
            raise ValueError("Missing the required parameter `device_groups` when calling `create_iceberg_device_groups_device_groups_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 'device_groups' in params:
            body_params = params['device_groups']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_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/device-groups/', '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_devices_devices_by_id(self, devices, **kwargs):  # noqa: E501
        """Update or create multiple devices.  # noqa: E501

        Create/Update multiple devices. The new content for the existing devices updates the existing content and the new devices are created.  # 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_devices_devices_by_id(devices, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DevicesSchema devices: devicesbody 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_devices_devices_by_id_with_http_info(devices, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_devices_devices_by_id_with_http_info(devices, **kwargs)  # noqa: E501
            return data

    def create_iceberg_devices_devices_by_id_with_http_info(self, devices, **kwargs):  # noqa: E501
        """Update or create multiple devices.  # noqa: E501

        Create/Update multiple devices. The new content for the existing devices updates the existing content and the new devices are created.  # 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_devices_devices_by_id_with_http_info(devices, async_req=True)
        >>> result = thread.get()

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

        all_params = ['devices', '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_devices_devices_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'devices' is set
        if ('devices' not in params or
                params['devices'] is None):
            raise ValueError("Missing the required parameter `devices` when calling `create_iceberg_devices_devices_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 'devices' in params:
            body_params = params['devices']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_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/devices/', '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_network_group_network_group_by_id(self, network_group_name, network_group, **kwargs):  # noqa: E501
        """Update or create a network-group.  # noqa: E501

        Create/Update a network-group by `network-group-name`. The `network-group-name` parameter specified in URL and the request body must match. If the network-group already exists then, the existing network-group's configuration will be updated with the new content.  # 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_network_group_network_group_by_id(network_group_name, network_group, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: ID of network-group-name (required)
        :param NetworkGroupSchema network_group: network_groupbody 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_network_group_network_group_by_id_with_http_info(network_group_name, network_group, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_network_group_network_group_by_id_with_http_info(network_group_name, network_group, **kwargs)  # noqa: E501
            return data

    def create_iceberg_network_group_network_group_by_id_with_http_info(self, network_group_name, network_group, **kwargs):  # noqa: E501
        """Update or create a network-group.  # noqa: E501

        Create/Update a network-group by `network-group-name`. The `network-group-name` parameter specified in URL and the request body must match. If the network-group already exists then, the existing network-group's configuration will be updated with the new content.  # 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_network_group_network_group_by_id_with_http_info(network_group_name, network_group, async_req=True)
        >>> result = thread.get()

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

        all_params = ['network_group_name', 'network_group', '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_network_group_network_group_by_id" % 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 `create_iceberg_network_group_network_group_by_id`")  # noqa: E501
        # verify the required parameter 'network_group' is set
        if ('network_group' not in params or
                params['network_group'] is None):
            raise ValueError("Missing the required parameter `network_group` when calling `create_iceberg_network_group_network_group_by_id`")  # 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 = []

        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 'network_group' in params:
            body_params = params['network_group']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/network-group/{network_group_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_network_groups_network_groups_by_id(self, network_groups, **kwargs):  # noqa: E501
        """Update or create multiple network-groups.  # noqa: E501

        Create/Update multiple network-groups. The new content for the existing network-groups updates the existing content and the new network-groups are created.  # 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_network_groups_network_groups_by_id(network_groups, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NetworkGroupsSchema network_groups: network-groupsbody 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_network_groups_network_groups_by_id_with_http_info(network_groups, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_network_groups_network_groups_by_id_with_http_info(network_groups, **kwargs)  # noqa: E501
            return data

    def create_iceberg_network_groups_network_groups_by_id_with_http_info(self, network_groups, **kwargs):  # noqa: E501
        """Update or create multiple network-groups.  # noqa: E501

        Create/Update multiple network-groups. The new content for the existing network-groups updates the existing content and the new network-groups are created.  # 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_network_groups_network_groups_by_id_with_http_info(network_groups, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NetworkGroupsSchema network_groups: network-groupsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['network_groups', '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_network_groups_network_groups_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'network_groups' is set
        if ('network_groups' not in params or
                params['network_groups'] is None):
            raise ValueError("Missing the required parameter `network_groups` when calling `create_iceberg_network_groups_network_groups_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 'network_groups' in params:
            body_params = params['network_groups']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_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/network-groups/', '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_notification_notification_by_id(self, notification_name, notification, **kwargs):  # noqa: E501
        """Update or create a notification  # noqa: E501

        Create/Update a notification by `notification-name`. The `notification-name` specified in URL and the request body must match. If the notification already exists then, the existing notification's configuration will be updated with the new content.  # 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_notification_notification_by_id(notification_name, notification, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str notification_name: ID of notification-name (required)
        :param NotificationSchema notification: notificationbody 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_notification_notification_by_id_with_http_info(notification_name, notification, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_notification_notification_by_id_with_http_info(notification_name, notification, **kwargs)  # noqa: E501
            return data

    def create_iceberg_notification_notification_by_id_with_http_info(self, notification_name, notification, **kwargs):  # noqa: E501
        """Update or create a notification  # noqa: E501

        Create/Update a notification by `notification-name`. The `notification-name` specified in URL and the request body must match. If the notification already exists then, the existing notification's configuration will be updated with the new content.  # 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_notification_notification_by_id_with_http_info(notification_name, notification, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'notification_name' in params:
            path_params['notification_name'] = params['notification_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 'notification' in params:
            body_params = params['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/notification/{notification_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_notifications_notifications_by_id(self, notifications, **kwargs):  # noqa: E501
        """Update or create multiple notifications.  # noqa: E501

        Create/Update multiple notifications. The new content for the existing notifications updates the existing content and the new notifications are created.  # 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_notifications_notifications_by_id(notifications, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NotificationsSchema notifications: notificationsbody 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_notifications_notifications_by_id_with_http_info(notifications, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_notifications_notifications_by_id_with_http_info(notifications, **kwargs)  # noqa: E501
            return data

    def create_iceberg_notifications_notifications_by_id_with_http_info(self, notifications, **kwargs):  # noqa: E501
        """Update or create multiple notifications.  # noqa: E501

        Create/Update multiple notifications. The new content for the existing notifications updates the existing content and the new notifications are created.  # 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_notifications_notifications_by_id_with_http_info(notifications, async_req=True)
        >>> result = thread.get()

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

        all_params = ['notifications', '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_notifications_notifications_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'notifications' is set
        if ('notifications' not in params or
                params['notifications'] is None):
            raise ValueError("Missing the required parameter `notifications` when calling `create_iceberg_notifications_notifications_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 'notifications' in params:
            body_params = params['notifications']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_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/notifications/', '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_playbook_playbook_by_id(self, playbook_name, playbook, **kwargs):  # noqa: E501
        """Update or create a playbook.  # noqa: E501

        Create/Update a playbook by `playbook-name`. The `playbook-name` specified in URL and the request body must match. If the playbook already exists then, the existing playbook's configuration will be updated with the new content.  # 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_playbook_playbook_by_id(playbook_name, playbook, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str playbook_name: ID of playbook-name (required)
        :param PlaybookSchema playbook: playbookbody 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_playbook_playbook_by_id_with_http_info(playbook_name, playbook, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_playbook_playbook_by_id_with_http_info(playbook_name, playbook, **kwargs)  # noqa: E501
            return data

    def create_iceberg_playbook_playbook_by_id_with_http_info(self, playbook_name, playbook, **kwargs):  # noqa: E501
        """Update or create a playbook.  # noqa: E501

        Create/Update a playbook by `playbook-name`. The `playbook-name` specified in URL and the request body must match. If the playbook already exists then, the existing playbook's configuration will be updated with the new content.  # 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_playbook_playbook_by_id_with_http_info(playbook_name, playbook, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'playbook_name' in params:
            path_params['playbook_name'] = params['playbook_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 'playbook' in params:
            body_params = params['playbook']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/playbook/{playbook_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_playbooks_playbooks_by_id(self, playbooks, **kwargs):  # noqa: E501
        """Update or create multiple playbooks.  # noqa: E501

        Create/Update multiple playbooks. The new content for the existing playbooks updates the existing content and the new playbooks are created.  # 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_playbooks_playbooks_by_id(playbooks, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PlaybooksSchema playbooks: playbooksbody 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_playbooks_playbooks_by_id_with_http_info(playbooks, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_playbooks_playbooks_by_id_with_http_info(playbooks, **kwargs)  # noqa: E501
            return data

    def create_iceberg_playbooks_playbooks_by_id_with_http_info(self, playbooks, **kwargs):  # noqa: E501
        """Update or create multiple playbooks.  # noqa: E501

        Create/Update multiple playbooks. The new content for the existing playbooks updates the existing content and the new playbooks are created.  # 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_playbooks_playbooks_by_id_with_http_info(playbooks, async_req=True)
        >>> result = thread.get()

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

        all_params = ['playbooks', '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_playbooks_playbooks_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'playbooks' is set
        if ('playbooks' not in params or
                params['playbooks'] is None):
            raise ValueError("Missing the required parameter `playbooks` when calling `create_iceberg_playbooks_playbooks_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 'playbooks' in params:
            body_params = params['playbooks']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_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/playbooks/', '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_retention_policies_retention_policies_by_id(self, retention_policies, **kwargs):  # noqa: E501
        """Update or create multiple retention-policies.  # noqa: E501

        Create/Update multiple retention-policies. The new content for the existing retention-policies update the existing content and the new retention-policies are created.  # 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_retention_policies_retention_policies_by_id(retention_policies, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RetentionPoliciesSchema retention_policies: retention-policiesbody object 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_retention_policies_retention_policies_by_id_with_http_info(retention_policies, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_retention_policies_retention_policies_by_id_with_http_info(retention_policies, **kwargs)  # noqa: E501
            return data

    def create_iceberg_retention_policies_retention_policies_by_id_with_http_info(self, retention_policies, **kwargs):  # noqa: E501
        """Update or create multiple retention-policies.  # noqa: E501

        Create/Update multiple retention-policies. The new content for the existing retention-policies update the existing content and the new retention-policies are created.  # 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_retention_policies_retention_policies_by_id_with_http_info(retention_policies, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RetentionPoliciesSchema retention_policies: retention-policiesbody object object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['retention_policies', '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_retention_policies_retention_policies_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'retention_policies' is set
        if ('retention_policies' not in params or
                params['retention_policies'] is None):
            raise ValueError("Missing the required parameter `retention_policies` when calling `create_iceberg_retention_policies_retention_policies_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 'retention_policies' in params:
            body_params = params['retention_policies']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_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/retention-policies/', '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_retention_policy_retention_policy_by_id(self, retention_policy_name, retention_policy, **kwargs):  # noqa: E501
        """Update or create a retention-policy.  # noqa: E501

        Create/Update a retention-policy by `retention-policy-name`. The `retention-policy-name` specified in URL and the request body must match. If the retention-policy exists then, the existing retention-policy's configuration will be updated by the new content.  # 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_retention_policy_retention_policy_by_id(retention_policy_name, retention_policy, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str retention_policy_name: ID of retention-policy-name (required)
        :param RetentionPolicySchema retention_policy: retention_policybody 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_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, retention_policy, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, retention_policy, **kwargs)  # noqa: E501
            return data

    def create_iceberg_retention_policy_retention_policy_by_id_with_http_info(self, retention_policy_name, retention_policy, **kwargs):  # noqa: E501
        """Update or create a retention-policy.  # noqa: E501

        Create/Update a retention-policy by `retention-policy-name`. The `retention-policy-name` specified in URL and the request body must match. If the retention-policy exists then, the existing retention-policy's configuration will be updated by the new content.  # 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_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, retention_policy, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'retention_policy_name' in params:
            path_params['retention_policy_name'] = params['retention_policy_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 'retention_policy' in params:
            body_params = params['retention_policy']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/retention-policy/{retention_policy_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_system_destination_by_id(self, name, destination, **kwargs):  # noqa: E501
        """Create destination by name  # noqa: E501

        Create/Update a destination by `name`. The `name` specified in URL and the request body must match. If the destination exists then, the existing destination's configuration will be updated by the new content.  # 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_system_destination_by_id(name, destination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param DestinationSchema destination: destinationsbody 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_system_destination_by_id_with_http_info(name, destination, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_destination_by_id_with_http_info(name, destination, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_destination_by_id_with_http_info(self, name, destination, **kwargs):  # noqa: E501
        """Create destination by name  # noqa: E501

        Create/Update a destination by `name`. The `name` specified in URL and the request body must match. If the destination exists then, the existing destination's configuration will be updated by the new content.  # 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_system_destination_by_id_with_http_info(name, destination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param DestinationSchema destination: destinationsbody 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', 'destination', '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_system_destination_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_system_destination_by_id`")  # noqa: E501
        # verify the required parameter 'destination' is set
        if ('destination' not in params or
                params['destination'] is None):
            raise ValueError("Missing the required parameter `destination` when calling `create_iceberg_system_destination_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 'destination' in params:
            body_params = params['destination']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/report-generation/destination/{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_system_destinations(self, destinations, **kwargs):  # noqa: E501
        """Create destinations by name  # noqa: E501

        Create/Update multiple destinations. The new content for the existing destinations updates the existing content and the new destinations are created.  # 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_system_destinations(destinations, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DestinationsSchema destinations: destinationsbody 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_system_destinations_with_http_info(destinations, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_destinations_with_http_info(destinations, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_destinations_with_http_info(self, destinations, **kwargs):  # noqa: E501
        """Create destinations by name  # noqa: E501

        Create/Update multiple destinations. The new content for the existing destinations updates the existing content and the new destinations are created.  # 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_system_destinations_with_http_info(destinations, async_req=True)
        >>> result = thread.get()

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

        all_params = ['destinations', '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_system_destinations" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'destinations' is set
        if ('destinations' not in params or
                params['destinations'] is None):
            raise ValueError("Missing the required parameter `destinations` when calling `create_iceberg_system_destinations`")  # 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 'destinations' in params:
            body_params = params['destinations']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/report-generation/destinations/', '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_system_report_by_id(self, name, report, **kwargs):  # noqa: E501
        """Create report by name  # noqa: E501

        Create/Update a report by `name`. The `name` specified in URL and the request body must match. If the report exists then, the existing report's configuration will be updated by the new content.  # 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_system_report_by_id(name, report, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param ReportSchema report: reportsbody 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_system_report_by_id_with_http_info(name, report, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_report_by_id_with_http_info(name, report, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_report_by_id_with_http_info(self, name, report, **kwargs):  # noqa: E501
        """Create report by name  # noqa: E501

        Create/Update a report by `name`. The `name` specified in URL and the request body must match. If the report exists then, the existing report's configuration will be updated by the new content.  # 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_system_report_by_id_with_http_info(name, report, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param ReportSchema report: reportsbody 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', 'report', '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_system_report_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_system_report_by_id`")  # noqa: E501
        # verify the required parameter 'report' is set
        if ('report' not in params or
                params['report'] is None):
            raise ValueError("Missing the required parameter `report` when calling `create_iceberg_system_report_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 'report' in params:
            body_params = params['report']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/report-generation/report/{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_system_reports(self, reports, **kwargs):  # noqa: E501
        """Create reports by name  # noqa: E501

        Create/Update multiple reports. The new content for the existing reports updates the existing content and the new reports are created.  # 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_system_reports(reports, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReportsSchema reports: reportsbody 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_system_reports_with_http_info(reports, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_reports_with_http_info(reports, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_reports_with_http_info(self, reports, **kwargs):  # noqa: E501
        """Create reports by name  # noqa: E501

        Create/Update multiple reports. The new content for the existing reports updates the existing content and the new reports are created.  # 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_system_reports_with_http_info(reports, async_req=True)
        >>> result = thread.get()

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

        all_params = ['reports', '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_system_reports" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'reports' is set
        if ('reports' not in params or
                params['reports'] is None):
            raise ValueError("Missing the required parameter `reports` when calling `create_iceberg_system_reports`")  # 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 'reports' in params:
            body_params = params['reports']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/report-generation/reports/', '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_system_scheduler_by_id(self, name, scheduler, **kwargs):  # noqa: E501
        """Create scheduler by name  # noqa: E501

        Create/Update a scheduler by `name`. The `name` specified in URL and the request body must match. If the scheduler exists then, the existing scheduler's configuration will be updated by the new content.  # 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_system_scheduler_by_id(name, scheduler, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param SchedulerSchema scheduler: schedulerbody 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_system_scheduler_by_id_with_http_info(name, scheduler, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_scheduler_by_id_with_http_info(name, scheduler, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_scheduler_by_id_with_http_info(self, name, scheduler, **kwargs):  # noqa: E501
        """Create scheduler by name  # noqa: E501

        Create/Update a scheduler by `name`. The `name` specified in URL and the request body must match. If the scheduler exists then, the existing scheduler's configuration will be updated by the new content.  # 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_system_scheduler_by_id_with_http_info(name, scheduler, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param SchedulerSchema scheduler: schedulerbody 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', 'scheduler', '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_system_scheduler_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_system_scheduler_by_id`")  # noqa: E501
        # verify the required parameter 'scheduler' is set
        if ('scheduler' not in params or
                params['scheduler'] is None):
            raise ValueError("Missing the required parameter `scheduler` when calling `create_iceberg_system_scheduler_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 'scheduler' in params:
            body_params = params['scheduler']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/scheduler/{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_system_schedulers(self, schedulers, **kwargs):  # noqa: E501
        """Create schedulers by name  # noqa: E501

        Create/Update multiple schdeulers. The new content for the existing schedulers updates the existing content and the new schedulers are created.  # 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_system_schedulers(schedulers, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SchedulersSchema schedulers: schedulersbody 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_system_schedulers_with_http_info(schedulers, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_schedulers_with_http_info(schedulers, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_schedulers_with_http_info(self, schedulers, **kwargs):  # noqa: E501
        """Create schedulers by name  # noqa: E501

        Create/Update multiple schdeulers. The new content for the existing schedulers updates the existing content and the new schedulers are created.  # 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_system_schedulers_with_http_info(schedulers, async_req=True)
        >>> result = thread.get()

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

        all_params = ['schedulers', '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_system_schedulers" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'schedulers' is set
        if ('schedulers' not in params or
                params['schedulers'] is None):
            raise ValueError("Missing the required parameter `schedulers` when calling `create_iceberg_system_schedulers`")  # 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 'schedulers' in params:
            body_params = params['schedulers']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/schedulers/', '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_system_settings_destination_by_id(self, name, destination, **kwargs):  # noqa: E501
        """Create destination by name  # noqa: E501

        Create/Update a destination by `name`. The `name` specified in URL and the request body must match. If the destination exists then, the existing destination's configuration will be updated by the new content.  # 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_system_settings_destination_by_id(name, destination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param DestinationSchema destination: destinationsbody 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_system_settings_destination_by_id_with_http_info(name, destination, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_settings_destination_by_id_with_http_info(name, destination, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_settings_destination_by_id_with_http_info(self, name, destination, **kwargs):  # noqa: E501
        """Create destination by name  # noqa: E501

        Create/Update a destination by `name`. The `name` specified in URL and the request body must match. If the destination exists then, the existing destination's configuration will be updated by the new content.  # 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_system_settings_destination_by_id_with_http_info(name, destination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param DestinationSchema destination: destinationsbody 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', 'destination', '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_system_settings_destination_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_system_settings_destination_by_id`")  # noqa: E501
        # verify the required parameter 'destination' is set
        if ('destination' not in params or
                params['destination'] is None):
            raise ValueError("Missing the required parameter `destination` when calling `create_iceberg_system_settings_destination_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 'destination' in params:
            body_params = params['destination']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/report-generation/destination/{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_system_settings_destinations(self, destinations, **kwargs):  # noqa: E501
        """Create destinations by name  # noqa: E501

        Create/Update multiple destinations. The new content for the existing destinations updates the existing content and the new destinations are created.  # 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_system_settings_destinations(destinations, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DestinationsSchema destinations: destinationsbody 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_system_settings_destinations_with_http_info(destinations, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_settings_destinations_with_http_info(destinations, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_settings_destinations_with_http_info(self, destinations, **kwargs):  # noqa: E501
        """Create destinations by name  # noqa: E501

        Create/Update multiple destinations. The new content for the existing destinations updates the existing content and the new destinations are created.  # 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_system_settings_destinations_with_http_info(destinations, async_req=True)
        >>> result = thread.get()

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

        all_params = ['destinations', '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_system_settings_destinations" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'destinations' is set
        if ('destinations' not in params or
                params['destinations'] is None):
            raise ValueError("Missing the required parameter `destinations` when calling `create_iceberg_system_settings_destinations`")  # 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 'destinations' in params:
            body_params = params['destinations']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/report-generation/destinations/', '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_system_settings_report_by_id(self, name, report, **kwargs):  # noqa: E501
        """Create report by name  # noqa: E501

        Create/Update a report by `name`. The `name` specified in URL and the request body must match. If the report exists then, the existing report's configuration will be updated by the new content.  # 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_system_settings_report_by_id(name, report, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param ReportSchema report: reportsbody 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_system_settings_report_by_id_with_http_info(name, report, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_settings_report_by_id_with_http_info(name, report, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_settings_report_by_id_with_http_info(self, name, report, **kwargs):  # noqa: E501
        """Create report by name  # noqa: E501

        Create/Update a report by `name`. The `name` specified in URL and the request body must match. If the report exists then, the existing report's configuration will be updated by the new content.  # 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_system_settings_report_by_id_with_http_info(name, report, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param ReportSchema report: reportsbody 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', 'report', '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_system_settings_report_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_system_settings_report_by_id`")  # noqa: E501
        # verify the required parameter 'report' is set
        if ('report' not in params or
                params['report'] is None):
            raise ValueError("Missing the required parameter `report` when calling `create_iceberg_system_settings_report_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 'report' in params:
            body_params = params['report']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/report-generation/report/{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_system_settings_reports(self, reports, **kwargs):  # noqa: E501
        """Create reports by name  # noqa: E501

        Create/Update multiple reports. The new content for the existing reports updates the existing content and the new reports are created.  # 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_system_settings_reports(reports, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReportsSchema reports: reportsbody 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_system_settings_reports_with_http_info(reports, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_settings_reports_with_http_info(reports, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_settings_reports_with_http_info(self, reports, **kwargs):  # noqa: E501
        """Create reports by name  # noqa: E501

        Create/Update multiple reports. The new content for the existing reports updates the existing content and the new reports are created.  # 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_system_settings_reports_with_http_info(reports, async_req=True)
        >>> result = thread.get()

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

        all_params = ['reports', '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_system_settings_reports" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'reports' is set
        if ('reports' not in params or
                params['reports'] is None):
            raise ValueError("Missing the required parameter `reports` when calling `create_iceberg_system_settings_reports`")  # 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 'reports' in params:
            body_params = params['reports']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/report-generation/reports/', '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_system_settings_scheduler_by_id(self, name, scheduler, **kwargs):  # noqa: E501
        """Create scheduler by name  # noqa: E501

        Create/Update a scheduler by `name`. The `name` specified in URL and the request body must match. If the scheduler exists then, the existing scheduler's configuration will be updated by the new content.  # 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_system_settings_scheduler_by_id(name, scheduler, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param SchedulerSchema scheduler: schedulerbody 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_system_settings_scheduler_by_id_with_http_info(name, scheduler, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_settings_scheduler_by_id_with_http_info(name, scheduler, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_settings_scheduler_by_id_with_http_info(self, name, scheduler, **kwargs):  # noqa: E501
        """Create scheduler by name  # noqa: E501

        Create/Update a scheduler by `name`. The `name` specified in URL and the request body must match. If the scheduler exists then, the existing scheduler's configuration will be updated by the new content.  # 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_system_settings_scheduler_by_id_with_http_info(name, scheduler, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param SchedulerSchema scheduler: schedulerbody 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', 'scheduler', '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_system_settings_scheduler_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_system_settings_scheduler_by_id`")  # noqa: E501
        # verify the required parameter 'scheduler' is set
        if ('scheduler' not in params or
                params['scheduler'] is None):
            raise ValueError("Missing the required parameter `scheduler` when calling `create_iceberg_system_settings_scheduler_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 'scheduler' in params:
            body_params = params['scheduler']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/scheduler/{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_system_settings_schedulers(self, schedulers, **kwargs):  # noqa: E501
        """Create schedulers by name  # noqa: E501

        Create/Update multiple schdeulers. The new content for the existing schedulers updates the existing content and the new schedulers are created.  # 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_system_settings_schedulers(schedulers, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SchedulersSchema schedulers: schedulersbody 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_system_settings_schedulers_with_http_info(schedulers, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_settings_schedulers_with_http_info(schedulers, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_settings_schedulers_with_http_info(self, schedulers, **kwargs):  # noqa: E501
        """Create schedulers by name  # noqa: E501

        Create/Update multiple schdeulers. The new content for the existing schedulers updates the existing content and the new schedulers are created.  # 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_system_settings_schedulers_with_http_info(schedulers, async_req=True)
        >>> result = thread.get()

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

        all_params = ['schedulers', '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_system_settings_schedulers" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'schedulers' is set
        if ('schedulers' not in params or
                params['schedulers'] is None):
            raise ValueError("Missing the required parameter `schedulers` when calling `create_iceberg_system_settings_schedulers`")  # 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 'schedulers' in params:
            body_params = params['schedulers']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/schedulers/', '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_system_settings_system_settings_by_id(self, system_settings, **kwargs):  # noqa: E501
        """Create system-settings  # noqa: E501

        Create/Update system-settings to populate persis-raw-data, schedulers, destinations and reports.  # 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_system_settings_system_settings_by_id(system_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SystemSettingsSchema system_settings: system_settings body object (required)
        :param str x_iam_token: authentication header object
        :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_iceberg_system_settings_system_settings_by_id_with_http_info(system_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_settings_system_settings_by_id_with_http_info(system_settings, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_settings_system_settings_by_id_with_http_info(self, system_settings, **kwargs):  # noqa: E501
        """Create system-settings  # noqa: E501

        Create/Update system-settings to populate persis-raw-data, schedulers, destinations and reports.  # 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_system_settings_system_settings_by_id_with_http_info(system_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SystemSettingsSchema system_settings: system_settings body object (required)
        :param str x_iam_token: authentication header object
        :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 = ['system_settings', 'x_iam_token', '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_iceberg_system_settings_system_settings_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'system_settings' is set
        if ('system_settings' not in params or
                params['system_settings'] is None):
            raise ValueError("Missing the required parameter `system_settings` when calling `create_iceberg_system_settings_system_settings_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 = {}
        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 'system_settings' in params:
            body_params = params['system_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/system-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_system_system_by_id(self, system_settings, **kwargs):  # noqa: E501
        """Create system  # noqa: E501

        Create/Update system to populate persist-raw-data, schedulers, destinations and reports.  # 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_system_system_by_id(system_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SystemSettingsSchema system_settings: system_settings body object (required)
        :param str x_iam_token: authentication header object
        :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_iceberg_system_system_by_id_with_http_info(system_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_system_system_by_id_with_http_info(system_settings, **kwargs)  # noqa: E501
            return data

    def create_iceberg_system_system_by_id_with_http_info(self, system_settings, **kwargs):  # noqa: E501
        """Create system  # noqa: E501

        Create/Update system to populate persist-raw-data, schedulers, destinations and reports.  # 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_system_system_by_id_with_http_info(system_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SystemSettingsSchema system_settings: system_settings body object (required)
        :param str x_iam_token: authentication header object
        :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 = ['system_settings', 'x_iam_token', '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_iceberg_system_system_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'system_settings' is set
        if ('system_settings' not in params or
                params['system_settings'] is None):
            raise ValueError("Missing the required parameter `system_settings` when calling `create_iceberg_system_system_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 = {}
        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 'system_settings' in params:
            body_params = params['system_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/system/', '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_topic_rule_rule_by_id(self, topic_name, rule_name, rule, **kwargs):  # noqa: E501
        """Update or create a rule.  # noqa: E501

        Create/Update a rule by `rule-name`. The `rule-name` specified in URL and the request body must match. If the rule already exists then, the existing rule's configuration will be updated with the new content  # 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_topic_rule_rule_by_id(topic_name, rule_name, rule, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str rule_name: ID of rule-name (required)
        :param RuleSchema rule: rulebody 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_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, rule, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, rule, **kwargs)  # noqa: E501
            return data

    def create_iceberg_topic_rule_rule_by_id_with_http_info(self, topic_name, rule_name, rule, **kwargs):  # noqa: E501
        """Update or create a rule.  # noqa: E501

        Create/Update a rule by `rule-name`. The `rule-name` specified in URL and the request body must match. If the rule already exists then, the existing rule's configuration will be updated with the new content  # 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_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, rule, async_req=True)
        >>> result = thread.get()

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

        all_params = ['topic_name', 'rule_name', 'rule', '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_topic_rule_rule_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 `create_iceberg_topic_rule_rule_by_id`")  # noqa: E501
        # verify the required parameter 'rule_name' is set
        if ('rule_name' not in params or
                params['rule_name'] is None):
            raise ValueError("Missing the required parameter `rule_name` when calling `create_iceberg_topic_rule_rule_by_id`")  # noqa: E501
        # verify the required parameter 'rule' is set
        if ('rule' not in params or
                params['rule'] is None):
            raise ValueError("Missing the required parameter `rule` when calling `create_iceberg_topic_rule_rule_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_name']  # noqa: E501
        if 'rule_name' in params:
            path_params['rule_name'] = params['rule_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 'rule' in params:
            body_params = params['rule']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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}/rule/{rule_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_topic_topic_by_id(self, topic_name, topic, **kwargs):  # noqa: E501
        """Update or create a topic.  # noqa: E501

        Create/Update a topic by `topic-name`. The `topic-name` specified in URL and the request body must match. If the topic already exists then, the existing topic's configuration will be updated with the new content.  # 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_topic_topic_by_id(topic_name, topic, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param TopicSchema topic: topicbody 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_topic_topic_by_id_with_http_info(topic_name, topic, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_topic_topic_by_id_with_http_info(topic_name, topic, **kwargs)  # noqa: E501
            return data

    def create_iceberg_topic_topic_by_id_with_http_info(self, topic_name, topic, **kwargs):  # noqa: E501
        """Update or create a topic.  # noqa: E501

        Create/Update a topic by `topic-name`. The `topic-name` specified in URL and the request body must match. If the topic already exists then, the existing topic's configuration will be updated with the new content.  # 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_topic_topic_by_id_with_http_info(topic_name, topic, async_req=True)
        >>> result = thread.get()

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

        all_params = ['topic_name', 'topic', '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_topic_topic_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 `create_iceberg_topic_topic_by_id`")  # noqa: E501
        # verify the required parameter 'topic' is set
        if ('topic' not in params or
                params['topic'] is None):
            raise ValueError("Missing the required parameter `topic` when calling `create_iceberg_topic_topic_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_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 'topic' in params:
            body_params = params['topic']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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}/', '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_topics_topics_by_id(self, topics, **kwargs):  # noqa: E501
        """Update or create multiple topics.  # noqa: E501

        Create/Update multiple topics. The new content for the existing topics updates the existing content and the new topics are created.  # 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_topics_topics_by_id(topics, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TopicsSchema topics: topicsbody 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_topics_topics_by_id_with_http_info(topics, **kwargs)  # noqa: E501
        else:
            (data) = self.create_iceberg_topics_topics_by_id_with_http_info(topics, **kwargs)  # noqa: E501
            return data

    def create_iceberg_topics_topics_by_id_with_http_info(self, topics, **kwargs):  # noqa: E501
        """Update or create multiple topics.  # noqa: E501

        Create/Update multiple topics. The new content for the existing topics updates the existing content and the new topics are created.  # 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_topics_topics_by_id_with_http_info(topics, async_req=True)
        >>> result = thread.get()

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

        all_params = ['topics', '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_topics_topics_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'topics' is set
        if ('topics' not in params or
                params['topics'] is None):
            raise ValueError("Missing the required parameter `topics` when calling `create_iceberg_topics_topics_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 'topics' in params:
            body_params = params['topics']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_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/topics/', '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_healthbot_ingest_byoi_ingest_mappings(self, **kwargs):  # noqa: E501
        """Delete all ingest-mappings.  # noqa: E501

        Delete all ingest-mappings.  # 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_mappings(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_byoi_ingest_mappings_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_byoi_ingest_mappings_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_byoi_ingest_mappings_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all ingest-mappings.  # noqa: E501

        Delete all ingest-mappings.  # 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_mappings_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_byoi_ingest_mappings" % 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/byoi/ingest-mappings/', '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_mappings(self, **kwargs):  # noqa: E501
        """Delete all ingest-mappings.  # noqa: E501

        Delete all ingest-mappings.  # 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_mappings(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_byoi_ingest_mappings_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_ingest_settings_byoi_ingest_mappings_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_ingest_settings_byoi_ingest_mappings_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all ingest-mappings.  # noqa: E501

        Delete all ingest-mappings.  # 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_mappings_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_byoi_ingest_mappings" % 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/byoi/ingest-mappings/', '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_organizations_organizations(self, **kwargs):  # noqa: E501
        """Delete all organizations.  # noqa: E501

        Delete all organizations. This will fail if any organization edge is referenced in any 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.delete_healthbot_organizations_organizations(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_organizations_organizations_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_organizations_organizations_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_healthbot_organizations_organizations_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all organizations.  # noqa: E501

        Delete all organizations. This will fail if any organization edge is referenced in any 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.delete_healthbot_organizations_organizations_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_organizations_organizations" % 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/organizations/', '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_topic_resource_resource_by_id(self, topic_name, resource_name, **kwargs):  # noqa: E501
        """Delete resource  # noqa: E501

        Delete 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.delete_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
        :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_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_healthbot_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, **kwargs)  # noqa: E501
            return data

    def delete_healthbot_topic_resource_resource_by_id_with_http_info(self, topic_name, resource_name, **kwargs):  # noqa: E501
        """Delete resource  # noqa: E501

        Delete 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.delete_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
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['topic_name', 'resource_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_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 `delete_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 `delete_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 = []

        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}/', '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_device_device_by_id(self, device_id, **kwargs):  # noqa: E501
        """Delete device.  # noqa: E501

        Delete a device by `device-id`. Delete will fail if the device is being referenced by 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.delete_iceberg_device_device_by_id(device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_id: ID of device-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_iceberg_device_device_by_id_with_http_info(device_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_device_device_by_id_with_http_info(device_id, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_device_device_by_id_with_http_info(self, device_id, **kwargs):  # noqa: E501
        """Delete device.  # noqa: E501

        Delete a device by `device-id`. Delete will fail if the device is being referenced by 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.delete_iceberg_device_device_by_id_with_http_info(device_id, async_req=True)
        >>> result = thread.get()

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

        all_params = ['device_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_iceberg_device_device_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 `delete_iceberg_device_device_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'device_id' in params:
            path_params['device_id'] = params['device_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/device/{device_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_iceberg_device_group_device_group_by_id(self, device_group_name, **kwargs):  # noqa: E501
        """Delete device-group.  # noqa: E501

        Delete a device-group by `device-group-name`. Delete will fail if the device-group's services are running.  # 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_device_group_device_group_by_id(device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: ID of device-group-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_iceberg_device_group_device_group_by_id_with_http_info(device_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_device_group_device_group_by_id_with_http_info(device_group_name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_device_group_device_group_by_id_with_http_info(self, device_group_name, **kwargs):  # noqa: E501
        """Delete device-group.  # noqa: E501

        Delete a device-group by `device-group-name`. Delete will fail if the device-group's services are running.  # 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_device_group_device_group_by_id_with_http_info(device_group_name, async_req=True)
        >>> result = thread.get()

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

        all_params = ['device_group_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_device_group_device_group_by_id" % 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 `delete_iceberg_device_group_device_group_by_id`")  # 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 = []

        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/device-group/{device_group_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_device_groups_device_groups_by_id(self, **kwargs):  # noqa: E501
        """Delete all device-groups.  # noqa: E501

        Delete all device-groups. Delete fails if services are still running for the 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.delete_iceberg_device_groups_device_groups_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_iceberg_device_groups_device_groups_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_device_groups_device_groups_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_device_groups_device_groups_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all device-groups.  # noqa: E501

        Delete all device-groups. Delete fails if services are still running for the 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.delete_iceberg_device_groups_device_groups_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_iceberg_device_groups_device_groups_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/device-groups/', '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_devices_devices_by_id(self, **kwargs):  # noqa: E501
        """Delete all devices.  # noqa: E501

        Delete all devices. This will fail if any device is referenced in any 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.delete_iceberg_devices_devices_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_iceberg_devices_devices_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_devices_devices_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_devices_devices_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all devices.  # noqa: E501

        Delete all devices. This will fail if any device is referenced in any 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.delete_iceberg_devices_devices_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_iceberg_devices_devices_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/devices/', '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_network_group_network_group_by_id(self, network_group_name, **kwargs):  # noqa: E501
        """Delete network-group.  # noqa: E501

        Delete a network-group by `network-group-name`. Delete will fail if the network-group's services are running.  # 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_network_group_network_group_by_id(network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: ID of network-group-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_iceberg_network_group_network_group_by_id_with_http_info(network_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_network_group_network_group_by_id_with_http_info(network_group_name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_network_group_network_group_by_id_with_http_info(self, network_group_name, **kwargs):  # noqa: E501
        """Delete network-group.  # noqa: E501

        Delete a network-group by `network-group-name`. Delete will fail if the network-group's services are running.  # 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_network_group_network_group_by_id_with_http_info(network_group_name, async_req=True)
        >>> result = thread.get()

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

        all_params = ['network_group_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_network_group_network_group_by_id" % 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 `delete_iceberg_network_group_network_group_by_id`")  # 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 = []

        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/network-group/{network_group_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_network_groups_network_groups_by_id(self, **kwargs):  # noqa: E501
        """Delete all network-groups.  # noqa: E501

        Delete all network-groups. Delete will fail if services are still running for the network 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.delete_iceberg_network_groups_network_groups_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_iceberg_network_groups_network_groups_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_network_groups_network_groups_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_network_groups_network_groups_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all network-groups.  # noqa: E501

        Delete all network-groups. Delete will fail if services are still running for the network 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.delete_iceberg_network_groups_network_groups_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_iceberg_network_groups_network_groups_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/network-groups/', '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_notification_notification_by_id(self, notification_name, **kwargs):  # noqa: E501
        """Delete a notification.  # noqa: E501

        Delete a notification by `notification-name`. Delete will fail if the notification is referenced by 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.delete_iceberg_notification_notification_by_id(notification_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str notification_name: ID of notification-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_iceberg_notification_notification_by_id_with_http_info(notification_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_notification_notification_by_id_with_http_info(notification_name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_notification_notification_by_id_with_http_info(self, notification_name, **kwargs):  # noqa: E501
        """Delete a notification.  # noqa: E501

        Delete a notification by `notification-name`. Delete will fail if the notification is referenced by 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.delete_iceberg_notification_notification_by_id_with_http_info(notification_name, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'notification_name' in params:
            path_params['notification_name'] = params['notification_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/notification/{notification_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_notifications_notifications_by_id(self, **kwargs):  # noqa: E501
        """Delete all notifications.  # noqa: E501

        Delete all notifications. This will fail if any notification is referenced in any 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.delete_iceberg_notifications_notifications_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_iceberg_notifications_notifications_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_notifications_notifications_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_notifications_notifications_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all notifications.  # noqa: E501

        Delete all notifications. This will fail if any notification is referenced in any 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.delete_iceberg_notifications_notifications_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_iceberg_notifications_notifications_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/notifications/', '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_playbook_playbook_by_id(self, playbook_name, **kwargs):  # noqa: E501
        """Delete a playbook.  # noqa: E501

        Delete a playbook by `playbook-name`. Delete will fail if the playbook is referenced by 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.delete_iceberg_playbook_playbook_by_id(playbook_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str playbook_name: ID of playbook-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_iceberg_playbook_playbook_by_id_with_http_info(playbook_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_playbook_playbook_by_id_with_http_info(playbook_name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_playbook_playbook_by_id_with_http_info(self, playbook_name, **kwargs):  # noqa: E501
        """Delete a playbook.  # noqa: E501

        Delete a playbook by `playbook-name`. Delete will fail if the playbook is referenced by 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.delete_iceberg_playbook_playbook_by_id_with_http_info(playbook_name, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'playbook_name' in params:
            path_params['playbook_name'] = params['playbook_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/playbook/{playbook_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_playbooks_playbooks_by_id(self, **kwargs):  # noqa: E501
        """Delete all playbooks.  # noqa: E501

        Delete all playbooks. This will fail if any playbook is referenced in any 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.delete_iceberg_playbooks_playbooks_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_iceberg_playbooks_playbooks_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_playbooks_playbooks_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_playbooks_playbooks_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all playbooks.  # noqa: E501

        Delete all playbooks. This will fail if any playbook is referenced in any 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.delete_iceberg_playbooks_playbooks_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_iceberg_playbooks_playbooks_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/playbooks/', '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_retention_policies_retention_policies_by_id(self, **kwargs):  # noqa: E501
        """Delete all retention-policies.  # noqa: E501

        Delete all the retention policies. This will fail if any retention-policy is referenced in any 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.delete_iceberg_retention_policies_retention_policies_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_iceberg_retention_policies_retention_policies_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_retention_policies_retention_policies_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_retention_policies_retention_policies_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all retention-policies.  # noqa: E501

        Delete all the retention policies. This will fail if any retention-policy is referenced in any 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.delete_iceberg_retention_policies_retention_policies_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_iceberg_retention_policies_retention_policies_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/retention-policies/', '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_retention_policy_retention_policy_by_id(self, retention_policy_name, **kwargs):  # noqa: E501
        """Delete a retention-policy.  # noqa: E501

        Delete a retention-policy by `retention-policy-name`. Delete will fail if the retention-policy is referenced by 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.delete_iceberg_retention_policy_retention_policy_by_id(retention_policy_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str retention_policy_name: ID of retention-policy-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_iceberg_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_retention_policy_retention_policy_by_id_with_http_info(self, retention_policy_name, **kwargs):  # noqa: E501
        """Delete a retention-policy.  # noqa: E501

        Delete a retention-policy by `retention-policy-name`. Delete will fail if the retention-policy is referenced by 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.delete_iceberg_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'retention_policy_name' in params:
            path_params['retention_policy_name'] = params['retention_policy_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/retention-policy/{retention_policy_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_system_destination_by_id(self, name, **kwargs):  # noqa: E501
        """Delete destination by name  # noqa: E501

        Delete a destination by `name`. Delete will fail if the destination is being referenced by a report.  # 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_system_destination_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (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_system_destination_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_destination_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_destination_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete destination by name  # noqa: E501

        Delete a destination by `name`. Delete will fail if the destination is being referenced by a report.  # 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_system_destination_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (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_system_destination_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_system_destination_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/system/report-generation/destination/{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_system_destinations(self, **kwargs):  # noqa: E501
        """Delete destinations by name  # noqa: E501

        Delete all destinations. This will fail if any destination is referenced in any report.  # 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_system_destinations(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_system_destinations_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_destinations_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_destinations_with_http_info(self, **kwargs):  # noqa: E501
        """Delete destinations by name  # noqa: E501

        Delete all destinations. This will fail if any destination is referenced in any report.  # 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_system_destinations_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_system_destinations" % 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/system/report-generation/destinations/', '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_system_report_by_id(self, name, **kwargs):  # noqa: E501
        """Delete report by name  # noqa: E501

        Delete a report by `name`. Delete will fail if the report is being referenced by a device-group or 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.delete_iceberg_system_report_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (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_system_report_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_report_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_report_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete report by name  # noqa: E501

        Delete a report by `name`. Delete will fail if the report is being referenced by a device-group or 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.delete_iceberg_system_report_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (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_system_report_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_system_report_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/system/report-generation/report/{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_system_reports(self, **kwargs):  # noqa: E501
        """Delete reports by name  # noqa: E501

        Delete all reports. This will fail if any report is referenced in any device-group or 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.delete_iceberg_system_reports(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_system_reports_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_reports_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_reports_with_http_info(self, **kwargs):  # noqa: E501
        """Delete reports by name  # noqa: E501

        Delete all reports. This will fail if any report is referenced in any device-group or 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.delete_iceberg_system_reports_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_system_reports" % 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/system/report-generation/reports/', '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_system_scheduler_by_id(self, name, **kwargs):  # noqa: E501
        """Delete scheduler by name  # noqa: E501

        Delete a scheduler by `name`. Delete will fail if the scheduler is being referenced by a report.  # 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_system_scheduler_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (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_system_scheduler_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_scheduler_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_scheduler_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete scheduler by name  # noqa: E501

        Delete a scheduler by `name`. Delete will fail if the scheduler is being referenced by a report.  # 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_system_scheduler_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (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_system_scheduler_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_system_scheduler_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/system/scheduler/{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_system_schedulers(self, **kwargs):  # noqa: E501
        """Delete schedulers by name  # noqa: E501

        Delete all schedulers. This will fail if any scheduler is referenced in any report.  # 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_system_schedulers(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_system_schedulers_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_schedulers_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_schedulers_with_http_info(self, **kwargs):  # noqa: E501
        """Delete schedulers by name  # noqa: E501

        Delete all schedulers. This will fail if any scheduler is referenced in any report.  # 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_system_schedulers_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_system_schedulers" % 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/system/schedulers/', '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_system_settings_destination_by_id(self, name, **kwargs):  # noqa: E501
        """Delete destination by name  # noqa: E501

        Delete a destination by `name`. Delete will fail if the destination is being referenced by a report.  # 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_system_settings_destination_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (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_system_settings_destination_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_settings_destination_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_settings_destination_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete destination by name  # noqa: E501

        Delete a destination by `name`. Delete will fail if the destination is being referenced by a report.  # 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_system_settings_destination_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (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_system_settings_destination_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_system_settings_destination_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/system-settings/report-generation/destination/{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_system_settings_destinations(self, **kwargs):  # noqa: E501
        """Delete destinations by name  # noqa: E501

        Delete all destinations. This will fail if any destination is referenced in any report.  # 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_system_settings_destinations(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_system_settings_destinations_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_settings_destinations_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_settings_destinations_with_http_info(self, **kwargs):  # noqa: E501
        """Delete destinations by name  # noqa: E501

        Delete all destinations. This will fail if any destination is referenced in any report.  # 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_system_settings_destinations_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_system_settings_destinations" % 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/system-settings/report-generation/destinations/', '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_system_settings_report_by_id(self, name, **kwargs):  # noqa: E501
        """Delete report by name  # noqa: E501

        Delete a report by `name`. Delete will fail if the report is being referenced by a device-group or 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.delete_iceberg_system_settings_report_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (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_system_settings_report_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_settings_report_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_settings_report_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete report by name  # noqa: E501

        Delete a report by `name`. Delete will fail if the report is being referenced by a device-group or 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.delete_iceberg_system_settings_report_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (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_system_settings_report_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_system_settings_report_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/system-settings/report-generation/report/{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_system_settings_reports(self, **kwargs):  # noqa: E501
        """Delete reports by name  # noqa: E501

        Delete all reports. This will fail if any report is referenced in any device-group or 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.delete_iceberg_system_settings_reports(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_system_settings_reports_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_settings_reports_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_settings_reports_with_http_info(self, **kwargs):  # noqa: E501
        """Delete reports by name  # noqa: E501

        Delete all reports. This will fail if any report is referenced in any device-group or 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.delete_iceberg_system_settings_reports_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_system_settings_reports" % 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/system-settings/report-generation/reports/', '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_system_settings_scheduler_by_id(self, name, **kwargs):  # noqa: E501
        """Delete scheduler by name  # noqa: E501

        Delete a scheduler by `name`. Delete will fail if the scheduler is being referenced by a report.  # 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_system_settings_scheduler_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (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_system_settings_scheduler_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_settings_scheduler_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_settings_scheduler_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete scheduler by name  # noqa: E501

        Delete a scheduler by `name`. Delete will fail if the scheduler is being referenced by a report.  # 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_system_settings_scheduler_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (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_system_settings_scheduler_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_system_settings_scheduler_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/system-settings/scheduler/{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_system_settings_schedulers(self, **kwargs):  # noqa: E501
        """Delete schedulers by name  # noqa: E501

        Delete all schedulers. This will fail if any scheduler is referenced in any report.  # 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_system_settings_schedulers(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_system_settings_schedulers_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_settings_schedulers_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_settings_schedulers_with_http_info(self, **kwargs):  # noqa: E501
        """Delete schedulers by name  # noqa: E501

        Delete all schedulers. This will fail if any scheduler is referenced in any report.  # 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_system_settings_schedulers_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_system_settings_schedulers" % 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/system-settings/schedulers/', '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_system_settings_system_settings_by_id(self, **kwargs):  # noqa: E501
        """Delete system-settings  # noqa: E501

        Delete system-settings. This will delete all the reports, destinations and schedulers. The request will fail of any of the reports is being referenced by a device-group or 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.delete_iceberg_system_settings_system_settings_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_iceberg_system_settings_system_settings_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_settings_system_settings_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_settings_system_settings_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete system-settings  # noqa: E501

        Delete system-settings. This will delete all the reports, destinations and schedulers. The request will fail of any of the reports is being referenced by a device-group or 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.delete_iceberg_system_settings_system_settings_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_iceberg_system_settings_system_settings_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/system-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_system_system_by_id(self, **kwargs):  # noqa: E501
        """Delete system  # noqa: E501

        Delete system. This will delete all the reports, destinations and schedulers. The request will fail of any of the reports is being referenced by a device-group or 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.delete_iceberg_system_system_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_iceberg_system_system_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_system_system_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_system_system_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete system  # noqa: E501

        Delete system. This will delete all the reports, destinations and schedulers. The request will fail of any of the reports is being referenced by a device-group or 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.delete_iceberg_system_system_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_iceberg_system_system_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/system/', '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_topic_rule_rule_by_id(self, topic_name, rule_name, **kwargs):  # noqa: E501
        """Delete a rule.  # noqa: E501

        Delete a rule by `rule-name`. Delete will fail if the rule is referenced by any other playbook.  # 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_topic_rule_rule_by_id(topic_name, rule_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str rule_name: ID of rule-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_iceberg_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_topic_rule_rule_by_id_with_http_info(self, topic_name, rule_name, **kwargs):  # noqa: E501
        """Delete a rule.  # noqa: E501

        Delete a rule by `rule-name`. Delete will fail if the rule is referenced by any other playbook.  # 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_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, async_req=True)
        >>> result = thread.get()

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

        all_params = ['topic_name', 'rule_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_topic_rule_rule_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 `delete_iceberg_topic_rule_rule_by_id`")  # noqa: E501
        # verify the required parameter 'rule_name' is set
        if ('rule_name' not in params or
                params['rule_name'] is None):
            raise ValueError("Missing the required parameter `rule_name` when calling `delete_iceberg_topic_rule_rule_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_name']  # noqa: E501
        if 'rule_name' in params:
            path_params['rule_name'] = params['rule_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/topic/{topic_name}/rule/{rule_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_topic_topic_by_id(self, topic_name, **kwargs):  # noqa: E501
        """Delete a topic.  # noqa: E501

        Delete a topic by `topic-name`. Delete will fail if the topic is referenced by any other playbook.  # 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_topic_topic_by_id(topic_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-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_iceberg_topic_topic_by_id_with_http_info(topic_name, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_topic_topic_by_id_with_http_info(topic_name, **kwargs)  # noqa: E501
            return data

    def delete_iceberg_topic_topic_by_id_with_http_info(self, topic_name, **kwargs):  # noqa: E501
        """Delete a topic.  # noqa: E501

        Delete a topic by `topic-name`. Delete will fail if the topic is referenced by any other playbook.  # 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_topic_topic_by_id_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 x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['topic_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_topic_topic_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 `delete_iceberg_topic_topic_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_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/topic/{topic_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_topics_topics_by_id(self, **kwargs):  # noqa: E501
        """Delete all topics.  # noqa: E501

        Delete all topics. This will fail if any topic is referenced in any playbook.  # 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_topics_topics_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_iceberg_topics_topics_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_iceberg_topics_topics_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_iceberg_topics_topics_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all topics.  # noqa: E501

        Delete all topics. This will fail if any topic is referenced in any playbook.  # 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_topics_topics_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_iceberg_topics_topics_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/topics/', '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 first_login(self, credenetial, **kwargs):  # noqa: E501
        """Change password after first login  # noqa: E501

        Change password in first login  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.first_login(credenetial, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Credenetial credenetial: set new password (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.first_login_with_http_info(credenetial, **kwargs)  # noqa: E501
        else:
            (data) = self.first_login_with_http_info(credenetial, **kwargs)  # noqa: E501
            return data

    def first_login_with_http_info(self, credenetial, **kwargs):  # noqa: E501
        """Change password after first login  # noqa: E501

        Change password in first login  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.first_login_with_http_info(credenetial, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Credenetial credenetial: set new password (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['credenetial']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method first_login" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'credenetial' is set
        if ('credenetial' not in params or
                params['credenetial'] is None):
            raise ValueError("Missing the required parameter `credenetial` when calling `first_login`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'credenetial' in params:
            body_params = params['credenetial']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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(
            '/first-login/', '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 initialize(self, **kwargs):  # noqa: E501
        """Initialize config-server  # noqa: E501

        Initialize config-server  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.initialize(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool restart_groups: Boolean variable is set to true if group services have to be restarted. Defaults to true.
        :param bool reload_rules: Boolean variable is set to true if default rules have to reloaded. Defaults to true.
        :param bool reload_playbooks: Boolean variable is set to true if default playbooks have to be reloaded. Defaults to true.
        :param bool reload_syslog_patterns: Boolean variable is set to true if syslog patterns have to be reloaded. Defaults to true.
        :param bool reload_syslog_pattern_sets: Boolean variable is set to true if syslog pattern sets have to be reloaded. Defaults to true.
        :param bool reload_flow_templates: Boolean variable is set to true if flow templates have to be reloaded. Defaults to true.
        :param bool reload_sflow_schema: Boolean variable is set to true if sflow schema has to be reloaded. Defaults 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.initialize_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.initialize_with_http_info(**kwargs)  # noqa: E501
            return data

    def initialize_with_http_info(self, **kwargs):  # noqa: E501
        """Initialize config-server  # noqa: E501

        Initialize config-server  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.initialize_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool restart_groups: Boolean variable is set to true if group services have to be restarted. Defaults to true.
        :param bool reload_rules: Boolean variable is set to true if default rules have to reloaded. Defaults to true.
        :param bool reload_playbooks: Boolean variable is set to true if default playbooks have to be reloaded. Defaults to true.
        :param bool reload_syslog_patterns: Boolean variable is set to true if syslog patterns have to be reloaded. Defaults to true.
        :param bool reload_syslog_pattern_sets: Boolean variable is set to true if syslog pattern sets have to be reloaded. Defaults to true.
        :param bool reload_flow_templates: Boolean variable is set to true if flow templates have to be reloaded. Defaults to true.
        :param bool reload_sflow_schema: Boolean variable is set to true if sflow schema has to be reloaded. Defaults to true.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'restart_groups', 'reload_rules', 'reload_playbooks', 'reload_syslog_patterns', 'reload_syslog_pattern_sets', 'reload_flow_templates', 'reload_sflow_schema']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method initialize" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'restart_groups' in params:
            query_params.append(('restart_groups', params['restart_groups']))  # noqa: E501
        if 'reload_rules' in params:
            query_params.append(('reload_rules', params['reload_rules']))  # noqa: E501
        if 'reload_playbooks' in params:
            query_params.append(('reload_playbooks', params['reload_playbooks']))  # noqa: E501
        if 'reload_syslog_patterns' in params:
            query_params.append(('reload_syslog_patterns', params['reload_syslog_patterns']))  # noqa: E501
        if 'reload_syslog_pattern_sets' in params:
            query_params.append(('reload_syslog_pattern_sets', params['reload_syslog_pattern_sets']))  # noqa: E501
        if 'reload_flow_templates' in params:
            query_params.append(('reload_flow_templates', params['reload_flow_templates']))  # noqa: E501
        if 'reload_sflow_schema' in params:
            query_params.append(('reload_sflow_schema', params['reload_sflow_schema']))  # 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', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/config/initialize/', '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_affected_groups(self, **kwargs):  # noqa: E501
        """Get all groups affected by un-committed configuration changes.  # noqa: E501

        Get all groups that are affected by the un-committed configuration changes.  # 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_affected_groups(async_req=True)
        >>> result = thread.get()

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

    def retrieve_affected_groups_with_http_info(self, **kwargs):  # noqa: E501
        """Get all groups affected by un-committed configuration changes.  # noqa: E501

        Get all groups that are affected by the un-committed configuration changes.  # 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_affected_groups_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :return: AffectedGroups
                 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_affected_groups" % 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(
            '/config/configuration/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AffectedGroups',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_device_group_status(self, device_group_name, **kwargs):  # noqa: E501
        """Get device-group's status.  # noqa: E501

        Get information about the status of a device-group's services.  # 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_device_group_status(device_group_name, async_req=True)
        >>> result = thread.get()

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

    def retrieve_device_group_status_with_http_info(self, device_group_name, **kwargs):  # noqa: E501
        """Get device-group's status.  # noqa: E501

        Get information about the status of a device-group's services.  # 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_device_group_status_with_http_info(device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: Name of device-group (required)
        :param str x_iam_token: authentication header object
        :return: ServiceStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['device_group_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 retrieve_device_group_status" % 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_device_group_status`")  # 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 = []

        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(
            '/device-group/{device_group_name}/status/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ServiceStatus',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_device_group_trigger_info(self, device_group_name, **kwargs):  # noqa: E501
        """Get device-group's trigger info.  # noqa: E501

        Get information about the triggers in 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_device_group_trigger_info(device_group_name, async_req=True)
        >>> result = thread.get()

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

    def retrieve_device_group_trigger_info_with_http_info(self, device_group_name, **kwargs):  # noqa: E501
        """Get device-group's trigger info.  # noqa: E501

        Get information about the triggers in 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_device_group_trigger_info_with_http_info(device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: Name of device-group (required)
        :param str x_iam_token: authentication header object
        :return: TriggerSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['device_group_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 retrieve_device_group_trigger_info" % 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_device_group_trigger_info`")  # 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 = []

        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(
            '/device-group/{device_group_name}/trigger_info/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TriggerSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_organizations_organizations(self, **kwargs):  # noqa: E501
        """Get all organizations' configuration.  # noqa: E501

        Get the configuration details of all organizations.  # 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_organizations_organizations(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: OrganizationsSchema
                 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_organizations_organizations_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_healthbot_organizations_organizations_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_healthbot_organizations_organizations_with_http_info(self, **kwargs):  # noqa: E501
        """Get all organizations' configuration.  # noqa: E501

        Get the configuration details of all organizations.  # 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_organizations_organizations_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 un-committed configuration
        :return: OrganizationsSchema
                 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_organizations_organizations" % 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/organizations/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='OrganizationsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_device_device(self, **kwargs):  # noqa: E501
        """List all device-ids.  # noqa: E501

        Get a list of all the device IDs.  # 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_device_device(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: 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_iceberg_device_device_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_device_device_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_device_device_with_http_info(self, **kwargs):  # noqa: E501
        """List all device-ids.  # noqa: E501

        Get a list of all the device IDs.  # 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_device_device_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 un-committed 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_device_device" % 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/device/', '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_device_device_by_id(self, device_id, **kwargs):  # noqa: E501
        """Get a device's configuration.  # noqa: E501

        Get the configuration details of a device by its `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_iceberg_device_device_by_id(device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_id: ID of device-id (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: DeviceSchema
                 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_device_device_by_id_with_http_info(device_id, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_device_device_by_id_with_http_info(device_id, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_device_device_by_id_with_http_info(self, device_id, **kwargs):  # noqa: E501
        """Get a device's configuration.  # noqa: E501

        Get the configuration details of a device by its `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_iceberg_device_device_by_id_with_http_info(device_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_id: ID of device-id (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: DeviceSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['device_id', '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_device_device_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_iceberg_device_device_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 '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/device/{device_id}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeviceSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_device_group_device_group(self, **kwargs):  # noqa: E501
        """List all device-group names.  # noqa: E501

        Get a list of all the device-group 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_iceberg_device_group_device_group(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: 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_iceberg_device_group_device_group_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_device_group_device_group_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_device_group_device_group_with_http_info(self, **kwargs):  # noqa: E501
        """List all device-group names.  # noqa: E501

        Get a list of all the device-group 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_iceberg_device_group_device_group_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 un-committed 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_device_group_device_group" % 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/device-group/', '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_device_group_device_group_by_id(self, device_group_name, **kwargs):  # noqa: E501
        """Get device-group's configuration.  # noqa: E501

        Get configuration details of a device group by the device group 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_iceberg_device_group_device_group_by_id(device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: ID of device-group-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: DeviceGroupSchema
                 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_device_group_device_group_by_id_with_http_info(device_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_device_group_device_group_by_id_with_http_info(device_group_name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_device_group_device_group_by_id_with_http_info(self, device_group_name, **kwargs):  # noqa: E501
        """Get device-group's configuration.  # noqa: E501

        Get configuration details of a device group by the device group 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_iceberg_device_group_device_group_by_id_with_http_info(device_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: ID of device-group-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: DeviceGroupSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['device_group_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_device_group_device_group_by_id" % 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_iceberg_device_group_device_group_by_id`")  # 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 '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/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='DeviceGroupSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_device_groups_device_groups(self, **kwargs):  # noqa: E501
        """Get all device-groups' configuration.  # noqa: E501

        Get configuration details of all the 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_iceberg_device_groups_device_groups(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: DeviceGroupsSchema
                 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_device_groups_device_groups_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_device_groups_device_groups_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_device_groups_device_groups_with_http_info(self, **kwargs):  # noqa: E501
        """Get all device-groups' configuration.  # noqa: E501

        Get configuration details of all the 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_iceberg_device_groups_device_groups_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 un-committed configuration
        :return: DeviceGroupsSchema
                 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_device_groups_device_groups" % 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/device-groups/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeviceGroupsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_devices_devices(self, **kwargs):  # noqa: E501
        """Get all devices' configuration.  # noqa: E501

        Get the configuration details of all devices.  # 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_devices_devices(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: DevicesSchema
                 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_devices_devices_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_devices_devices_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_devices_devices_with_http_info(self, **kwargs):  # noqa: E501
        """Get all devices' configuration.  # noqa: E501

        Get the configuration details of all devices.  # 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_devices_devices_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 un-committed configuration
        :return: DevicesSchema
                 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_devices_devices" % 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/devices/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicesSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_network_group_network_group(self, **kwargs):  # noqa: E501
        """List all network-group names.  # noqa: E501

        Get a list of all the `network-group-name`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_iceberg_network_group_network_group(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: 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_iceberg_network_group_network_group_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_network_group_network_group_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_network_group_network_group_with_http_info(self, **kwargs):  # noqa: E501
        """List all network-group names.  # noqa: E501

        Get a list of all the `network-group-name`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_iceberg_network_group_network_group_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 un-committed 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_network_group_network_group" % 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/network-group/', '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_network_group_network_group_by_id(self, network_group_name, **kwargs):  # noqa: E501
        """Get network-group's configuration.  # noqa: E501

        Get the configuration details of a network group by its network group 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_iceberg_network_group_network_group_by_id(network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: ID of network-group-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: NetworkGroupSchema
                 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_network_group_network_group_by_id_with_http_info(network_group_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_network_group_network_group_by_id_with_http_info(network_group_name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_network_group_network_group_by_id_with_http_info(self, network_group_name, **kwargs):  # noqa: E501
        """Get network-group's configuration.  # noqa: E501

        Get the configuration details of a network group by its network group 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_iceberg_network_group_network_group_by_id_with_http_info(network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: ID of network-group-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: NetworkGroupSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['network_group_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_network_group_network_group_by_id" % 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_iceberg_network_group_network_group_by_id`")  # 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 '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/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='NetworkGroupSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_network_groups_network_groups(self, **kwargs):  # noqa: E501
        """Get all network-groups' configuration.  # noqa: E501

        Get configuration of all network-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_iceberg_network_groups_network_groups(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: NetworkGroupsSchema
                 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_network_groups_network_groups_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_network_groups_network_groups_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_network_groups_network_groups_with_http_info(self, **kwargs):  # noqa: E501
        """Get all network-groups' configuration.  # noqa: E501

        Get configuration of all network-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_iceberg_network_groups_network_groups_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 un-committed configuration
        :return: NetworkGroupsSchema
                 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_network_groups_network_groups" % 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/network-groups/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NetworkGroupsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_notification_notification(self, **kwargs):  # noqa: E501
        """List all notification-names.  # noqa: E501

        Get a list of all the `notification-name`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_iceberg_notification_notification(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: 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_iceberg_notification_notification_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_notification_notification_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_notification_notification_with_http_info(self, **kwargs):  # noqa: E501
        """List all notification-names.  # noqa: E501

        Get a list of all the `notification-name`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_iceberg_notification_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 un-committed 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_notification_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/notification/', '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_notification_notification_by_id(self, notification_name, **kwargs):  # noqa: E501
        """Get a notification's configuration.  # noqa: E501

        Get the configuration details of a notification by `notification-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_iceberg_notification_notification_by_id(notification_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str notification_name: ID of notification-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: NotificationSchema
                 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_notification_notification_by_id_with_http_info(notification_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_notification_notification_by_id_with_http_info(notification_name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_notification_notification_by_id_with_http_info(self, notification_name, **kwargs):  # noqa: E501
        """Get a notification's configuration.  # noqa: E501

        Get the configuration details of a notification by `notification-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_iceberg_notification_notification_by_id_with_http_info(notification_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str notification_name: ID of notification-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: NotificationSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'notification_name' in params:
            path_params['notification_name'] = params['notification_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', 'application/x-gzip'])  # noqa: E501

        # HTTP 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/notification/{notification_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NotificationSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_notifications_notifications_by_id(self, **kwargs):  # noqa: E501
        """Get all notifications' configuration.  # noqa: E501

        Get the configuration details of all notifications.  # 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_notifications_notifications_by_id(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: NotificationsSchema
                 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_notifications_notifications_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_notifications_notifications_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_notifications_notifications_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Get all notifications' configuration.  # noqa: E501

        Get the configuration details of all notifications.  # 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_notifications_notifications_by_id_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 un-committed configuration
        :return: NotificationsSchema
                 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_notifications_notifications_by_id" % 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/notifications/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NotificationsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_playbook_playbook(self, **kwargs):  # noqa: E501
        """List all playbook-names.  # noqa: E501

        Get a list of all the `playbook-name`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_iceberg_playbook_playbook(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: 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_iceberg_playbook_playbook_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_playbook_playbook_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_playbook_playbook_with_http_info(self, **kwargs):  # noqa: E501
        """List all playbook-names.  # noqa: E501

        Get a list of all the `playbook-name`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_iceberg_playbook_playbook_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 un-committed 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_playbook_playbook" % 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/playbook/', '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_playbook_playbook_by_id(self, playbook_name, **kwargs):  # noqa: E501
        """Get a playbook's configuration.  # noqa: E501

        Get the configuration details of a playbook by `playbook-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_iceberg_playbook_playbook_by_id(playbook_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str playbook_name: ID of playbook-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :param bool download: Download as compressed .playbook file
        :return: PlaybookSchema
                 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_playbook_playbook_by_id_with_http_info(playbook_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_playbook_playbook_by_id_with_http_info(playbook_name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_playbook_playbook_by_id_with_http_info(self, playbook_name, **kwargs):  # noqa: E501
        """Get a playbook's configuration.  # noqa: E501

        Get the configuration details of a playbook by `playbook-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_iceberg_playbook_playbook_by_id_with_http_info(playbook_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str playbook_name: ID of playbook-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :param bool download: Download as compressed .playbook file
        :return: PlaybookSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'playbook_name' in params:
            path_params['playbook_name'] = params['playbook_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 '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/playbook/{playbook_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PlaybookSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_playbooks_playbooks_by_id(self, **kwargs):  # noqa: E501
        """Get all playbooks' configuration.  # noqa: E501

        Get the configuration of all playbooks.  # 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_playbooks_playbooks_by_id(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: PlaybooksSchema
                 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_playbooks_playbooks_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_playbooks_playbooks_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_playbooks_playbooks_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Get all playbooks' configuration.  # noqa: E501

        Get the configuration of all playbooks.  # 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_playbooks_playbooks_by_id_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 un-committed configuration
        :return: PlaybooksSchema
                 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_playbooks_playbooks_by_id" % 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/playbooks/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PlaybooksSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_retention_policies_retention_policies_by_id(self, **kwargs):  # noqa: E501
        """Get all retention-policies' configuration.  # noqa: E501

        Get the configuration of all the retention-policies.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_retention_policies_retention_policies_by_id(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: RetentionPoliciesSchema
                 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_retention_policies_retention_policies_by_id_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_retention_policies_retention_policies_by_id_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_retention_policies_retention_policies_by_id_with_http_info(self, **kwargs):  # noqa: E501
        """Get all retention-policies' configuration.  # noqa: E501

        Get the configuration of all the retention-policies.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_iceberg_retention_policies_retention_policies_by_id_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 un-committed configuration
        :return: RetentionPoliciesSchema
                 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_retention_policies_retention_policies_by_id" % 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/retention-policies/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RetentionPoliciesSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_retention_policy_retention_policy(self, **kwargs):  # noqa: E501
        """List all retention-policy-names.  # noqa: E501

        Get a list of all the `retention-policy-name`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_iceberg_retention_policy_retention_policy(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: 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_iceberg_retention_policy_retention_policy_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_retention_policy_retention_policy_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_retention_policy_retention_policy_with_http_info(self, **kwargs):  # noqa: E501
        """List all retention-policy-names.  # noqa: E501

        Get a list of all the `retention-policy-name`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_iceberg_retention_policy_retention_policy_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 un-committed 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_retention_policy_retention_policy" % 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/retention-policy/', '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_retention_policy_retention_policy_by_id(self, retention_policy_name, **kwargs):  # noqa: E501
        """Get a retention-policy's configuration.  # noqa: E501

        Get the configuration details of a retention policy by `retention-policy-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_iceberg_retention_policy_retention_policy_by_id(retention_policy_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str retention_policy_name: ID of retention-policy-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: RetentionPolicySchema
                 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_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_retention_policy_retention_policy_by_id_with_http_info(self, retention_policy_name, **kwargs):  # noqa: E501
        """Get a retention-policy's configuration.  # noqa: E501

        Get the configuration details of a retention policy by `retention-policy-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_iceberg_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str retention_policy_name: ID of retention-policy-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: RetentionPolicySchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'retention_policy_name' in params:
            path_params['retention_policy_name'] = params['retention_policy_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/retention-policy/{retention_policy_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RetentionPolicySchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_destination_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve destination by name  # noqa: E501

        Get the configuration details of a destination by its `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_iceberg_system_destination_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: DestinationSchema
                 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_system_destination_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_destination_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_destination_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve destination by name  # noqa: E501

        Get the configuration details of a destination by its `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_iceberg_system_destination_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: DestinationSchema
                 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_system_destination_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_system_destination_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/system/report-generation/destination/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DestinationSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_destinations(self, **kwargs):  # noqa: E501
        """Retrieve destinations by name  # noqa: E501

        Get the configuration details of all destinations.  # 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_system_destinations(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: DestinationsSchema
                 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_system_destinations_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_destinations_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_destinations_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve destinations by name  # noqa: E501

        Get the configuration details of all destinations.  # 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_system_destinations_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: DestinationsSchema
                 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_system_destinations" % 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/system/report-generation/destinations/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DestinationsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_report_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve report by name  # noqa: E501

        Get the configuration details of a report by its `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_iceberg_system_report_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: ReportSchema
                 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_system_report_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_report_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_report_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve report by name  # noqa: E501

        Get the configuration details of a report by its `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_iceberg_system_report_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: ReportSchema
                 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_system_report_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_system_report_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/system/report-generation/report/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ReportSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_reports(self, **kwargs):  # noqa: E501
        """Retrieve reports by name  # noqa: E501

        Get the configuration details of all reports.  # 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_system_reports(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: ReportsSchema
                 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_system_reports_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_reports_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_reports_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve reports by name  # noqa: E501

        Get the configuration details of all reports.  # 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_system_reports_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: ReportsSchema
                 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_system_reports" % 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/system/report-generation/reports/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ReportsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_scheduler_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve scheduler by name  # noqa: E501

        Get the configuration details of a scheduler by its `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_iceberg_system_scheduler_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SchedulerSchema
                 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_system_scheduler_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_scheduler_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_scheduler_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve scheduler by name  # noqa: E501

        Get the configuration details of a scheduler by its `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_iceberg_system_scheduler_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SchedulerSchema
                 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_system_scheduler_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_system_scheduler_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/system/scheduler/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SchedulerSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_schedulers(self, **kwargs):  # noqa: E501
        """Retrieve schedulers by name  # noqa: E501

        Get the configuration details of all schedulers.  # 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_system_schedulers(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: SchedulersSchema
                 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_system_schedulers_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_schedulers_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_schedulers_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve schedulers by name  # noqa: E501

        Get the configuration details of all schedulers.  # 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_system_schedulers_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: SchedulersSchema
                 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_system_schedulers" % 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/system/schedulers/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SchedulersSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_settings_destination_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve destination by name  # noqa: E501

        Get the configuration details of a destination by its `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_iceberg_system_settings_destination_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: DestinationSchema
                 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_system_settings_destination_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_settings_destination_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_settings_destination_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve destination by name  # noqa: E501

        Get the configuration details of a destination by its `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_iceberg_system_settings_destination_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: DestinationSchema
                 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_system_settings_destination_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_system_settings_destination_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/system-settings/report-generation/destination/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DestinationSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_settings_destinations(self, **kwargs):  # noqa: E501
        """Retrieve destinations by name  # noqa: E501

        Get the configuration details of all destinations.  # 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_system_settings_destinations(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: DestinationsSchema
                 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_system_settings_destinations_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_settings_destinations_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_settings_destinations_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve destinations by name  # noqa: E501

        Get the configuration details of all destinations.  # 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_system_settings_destinations_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: DestinationsSchema
                 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_system_settings_destinations" % 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/system-settings/report-generation/destinations/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DestinationsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_settings_report_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve report by name  # noqa: E501

        Get the configuration details of a report by its `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_iceberg_system_settings_report_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: ReportSchema
                 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_system_settings_report_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_settings_report_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_settings_report_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve report by name  # noqa: E501

        Get the configuration details of a report by its `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_iceberg_system_settings_report_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: ReportSchema
                 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_system_settings_report_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_system_settings_report_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/system-settings/report-generation/report/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ReportSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_settings_reports(self, **kwargs):  # noqa: E501
        """Retrieve reports by name  # noqa: E501

        Get the configuration details of all reports.  # 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_system_settings_reports(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: ReportsSchema
                 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_system_settings_reports_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_settings_reports_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_settings_reports_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve reports by name  # noqa: E501

        Get the configuration details of all reports.  # 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_system_settings_reports_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: ReportsSchema
                 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_system_settings_reports" % 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/system-settings/report-generation/reports/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ReportsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_settings_scheduler_by_id(self, name, **kwargs):  # noqa: E501
        """Retrieve scheduler by name  # noqa: E501

        Get the configuration details of a scheduler by its `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_iceberg_system_settings_scheduler_by_id(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SchedulerSchema
                 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_system_settings_scheduler_by_id_with_http_info(name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_settings_scheduler_by_id_with_http_info(name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_settings_scheduler_by_id_with_http_info(self, name, **kwargs):  # noqa: E501
        """Retrieve scheduler by name  # noqa: E501

        Get the configuration details of a scheduler by its `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_iceberg_system_settings_scheduler_by_id_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries undeployed configuration
        :return: SchedulerSchema
                 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_system_settings_scheduler_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_system_settings_scheduler_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/system-settings/scheduler/{name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SchedulerSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_settings_schedulers(self, **kwargs):  # noqa: E501
        """Retrieve schedulers by name  # noqa: E501

        Get the configuration details of all schedulers.  # 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_system_settings_schedulers(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: SchedulersSchema
                 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_system_settings_schedulers_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_settings_schedulers_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_settings_schedulers_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve schedulers by name  # noqa: E501

        Get the configuration details of all schedulers.  # 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_system_settings_schedulers_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: SchedulersSchema
                 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_system_settings_schedulers" % 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/system-settings/schedulers/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SchedulersSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_settings_system_settings(self, **kwargs):  # noqa: E501
        """Retrieve system-settings  # noqa: E501

        Retrieve system-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_system_settings_system_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: SystemSettingsSchema
                 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_system_settings_system_settings_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_settings_system_settings_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_settings_system_settings_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve system-settings  # noqa: E501

        Retrieve system-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_system_settings_system_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: SystemSettingsSchema
                 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_system_settings_system_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/system-settings/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SystemSettingsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_system_system(self, **kwargs):  # noqa: E501
        """Retrieve system data  # noqa: E501

        Retrieve system details  # 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_system_system(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: SystemSettingsSchema
                 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_system_system_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_system_system_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_system_system_with_http_info(self, **kwargs):  # noqa: E501
        """Retrieve system data  # noqa: E501

        Retrieve system details  # 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_system_system_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: SystemSettingsSchema
                 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_system_system" % 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/system/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SystemSettingsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_topic_rule_rule(self, topic_name, **kwargs):  # noqa: E501
        """List all rule-names in a topic.  # noqa: E501

        Get a list of all the `rule-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_iceberg_topic_rule_rule(topic_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str x_iam_token: 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_iceberg_topic_rule_rule_with_http_info(topic_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_topic_rule_rule_with_http_info(topic_name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_topic_rule_rule_with_http_info(self, topic_name, **kwargs):  # noqa: E501
        """List all rule-names in a topic.  # noqa: E501

        Get a list of all the `rule-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_iceberg_topic_rule_rule_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 x_iam_token: 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', '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_topic_rule_rule" % 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_iceberg_topic_rule_rule`")  # 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 '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/topic/{topic_name}/rule/', '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_topic_rule_rule_by_id(self, topic_name, rule_name, **kwargs):  # noqa: E501
        """Get a rule's configuration.  # noqa: E501

        Get the configuration details of a rule by `rule-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_iceberg_topic_rule_rule_by_id(topic_name, rule_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str rule_name: ID of rule-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :param bool download: Download a compressed .rule file
        :return: RuleSchema
                 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_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_topic_rule_rule_by_id_with_http_info(self, topic_name, rule_name, **kwargs):  # noqa: E501
        """Get a rule's configuration.  # noqa: E501

        Get the configuration details of a rule by `rule-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_iceberg_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str rule_name: ID of rule-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :param bool download: Download a compressed .rule file
        :return: RuleSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['topic_name', 'rule_name', 'x_iam_token', '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_iceberg_topic_rule_rule_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_iceberg_topic_rule_rule_by_id`")  # noqa: E501
        # verify the required parameter 'rule_name' is set
        if ('rule_name' not in params or
                params['rule_name'] is None):
            raise ValueError("Missing the required parameter `rule_name` when calling `retrieve_iceberg_topic_rule_rule_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_name']  # noqa: E501
        if 'rule_name' in params:
            path_params['rule_name'] = params['rule_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 '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/topic/{topic_name}/rule/{rule_name}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RuleSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_topic_topic(self, **kwargs):  # noqa: E501
        """List all topic-names.  # noqa: E501

        Get a list of all the `topic-name`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_iceberg_topic_topic(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: 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_iceberg_topic_topic_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_topic_topic_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_topic_topic_with_http_info(self, **kwargs):  # noqa: E501
        """List all topic-names.  # noqa: E501

        Get a list of all the `topic-name`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_iceberg_topic_topic_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 un-committed 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_topic_topic" % 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/topic/', '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_topic_topic_by_id(self, topic_name, **kwargs):  # noqa: E501
        """Get a topic's configuration.  # noqa: E501

        Get the configuration details of a topic by the `topic-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_iceberg_topic_topic_by_id(topic_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: TopicSchema
                 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_topic_topic_by_id_with_http_info(topic_name, **kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_topic_topic_by_id_with_http_info(topic_name, **kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_topic_topic_by_id_with_http_info(self, topic_name, **kwargs):  # noqa: E501
        """Get a topic's configuration.  # noqa: E501

        Get the configuration details of a topic by the `topic-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_iceberg_topic_topic_by_id_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 x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :return: TopicSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['topic_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_topic_topic_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_iceberg_topic_topic_by_id`")  # 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 '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/x-gzip'])  # noqa: E501

        # HTTP 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}/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TopicSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_topics_topics(self, **kwargs):  # noqa: E501
        """Get all topics' configuration.  # noqa: E501

        Get the configuration details of all topics.  # 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_topics_topics(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool working: true queries un-committed configuration
        :param str sort: asc/desc queries sorted configuration
        :return: TopicsSchema
                 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_topics_topics_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_iceberg_topics_topics_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_iceberg_topics_topics_with_http_info(self, **kwargs):  # noqa: E501
        """Get all topics' configuration.  # noqa: E501

        Get the configuration details of all topics.  # 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_topics_topics_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 un-committed configuration
        :param str sort: asc/desc queries sorted configuration
        :return: TopicsSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'working', 'sort']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_topics_topics" % 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
        if 'sort' in params:
            query_params.append(('sort', params['sort']))  # 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/topics/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TopicsSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_network_group_status(self, network_group_name, **kwargs):  # noqa: E501
        """Get network-group's status.  # noqa: E501

        Get information about the status of a network-group's services.  # 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_network_group_status(network_group_name, async_req=True)
        >>> result = thread.get()

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

    def retrieve_network_group_status_with_http_info(self, network_group_name, **kwargs):  # noqa: E501
        """Get network-group's status.  # noqa: E501

        Get information about the status of a network-group's services.  # 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_network_group_status_with_http_info(network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: Name of network-group (required)
        :param str x_iam_token: authentication header object
        :return: ServiceStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['network_group_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 retrieve_network_group_status" % 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_network_group_status`")  # 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 = []

        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(
            '/network-group/{network_group_name}/status/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ServiceStatus',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_network_group_trigger_info(self, network_group_name, **kwargs):  # noqa: E501
        """Get network-group's trigger info.  # noqa: E501

        Get information about the triggers in 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_network_group_trigger_info(network_group_name, async_req=True)
        >>> result = thread.get()

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

    def retrieve_network_group_trigger_info_with_http_info(self, network_group_name, **kwargs):  # noqa: E501
        """Get network-group's trigger info.  # noqa: E501

        Get information about the triggers in 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_network_group_trigger_info_with_http_info(network_group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: Name of network-group (required)
        :param str x_iam_token: authentication header object
        :return: TriggerSchema
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['network_group_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 retrieve_network_group_trigger_info" % 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_network_group_trigger_info`")  # 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 = []

        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(
            '/network-group/{network_group_name}/trigger_info/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TriggerSchema',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_orchestrator(self, **kwargs):  # noqa: E501
        """Get Orchestrator type  # noqa: E501

        Get orchestrator type. Will be one of kubernetes or compose.  # 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_orchestrator(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.retrieve_orchestrator_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.retrieve_orchestrator_with_http_info(**kwargs)  # noqa: E501
            return data

    def retrieve_orchestrator_with_http_info(self, **kwargs):  # noqa: E501
        """Get Orchestrator type  # noqa: E501

        Get orchestrator type. Will be one of kubernetes or compose.  # 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_orchestrator_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 retrieve_orchestrator" % 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', 'multipart/form-data'])  # noqa: E501

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/orchestrator/', '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 rollback_unsaved_configuration(self, **kwargs):  # noqa: E501
        """Delete the un-committed configuration.  # noqa: E501

        The API server follows a commit model. Unsaved configuration is called a working configuration. This API call deletes the working 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.rollback_unsaved_configuration(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool ems_sanity: DEBUG (Use with caution): roll-back a faulty transaction in HB-EMS communication
        :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.rollback_unsaved_configuration_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.rollback_unsaved_configuration_with_http_info(**kwargs)  # noqa: E501
            return data

    def rollback_unsaved_configuration_with_http_info(self, **kwargs):  # noqa: E501
        """Delete the un-committed configuration.  # noqa: E501

        The API server follows a commit model. Unsaved configuration is called a working configuration. This API call deletes the working 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.rollback_unsaved_configuration_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_iam_token: authentication header object
        :param bool ems_sanity: DEBUG (Use with caution): roll-back a faulty transaction in HB-EMS communication
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_iam_token', 'ems_sanity']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method rollback_unsaved_configuration" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'ems_sanity' in params:
            query_params.append(('ems_sanity', params['ems_sanity']))  # 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/configuration/', '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 update_healthbot_organizations_organizations(self, organizations, **kwargs):  # noqa: E501
        """Overwrite organizations.  # noqa: E501

        Overwrite the existing organizations configuration. New organizations are created and existing organizations are overwritten with new content. If some of the existing organizations are not present in the payload, such organizations are deleted. This will fail if any of the organization edges that are not present in the payload are referenced by 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.update_healthbot_organizations_organizations(organizations, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param OrganizationsSchema organizations: organizations 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_organizations_organizations_with_http_info(organizations, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_organizations_organizations_with_http_info(organizations, **kwargs)  # noqa: E501
            return data

    def update_healthbot_organizations_organizations_with_http_info(self, organizations, **kwargs):  # noqa: E501
        """Overwrite organizations.  # noqa: E501

        Overwrite the existing organizations configuration. New organizations are created and existing organizations are overwritten with new content. If some of the existing organizations are not present in the payload, such organizations are deleted. This will fail if any of the organization edges that are not present in the payload are referenced by 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.update_healthbot_organizations_organizations_with_http_info(organizations, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param OrganizationsSchema organizations: organizations 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 = ['organizations', '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_organizations_organizations" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'organizations' is set
        if ('organizations' not in params or
                params['organizations'] is None):
            raise ValueError("Missing the required parameter `organizations` when calling `update_healthbot_organizations_organizations`")  # 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 'organizations' in params:
            body_params = params['organizations']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/organizations/', '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_topic_resource_resource_by_id(self, topic_name, resource_name, resource, **kwargs):  # noqa: E501
        """Overwrite a resource  # noqa: E501

        Overwrite a rule by the `resource-name`. The `resource-name` specified in URL and the request body must match.  # 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_topic_resource_resource_by_id(topic_name, resource_name, resource, 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 ResourceSchema resource: resourcebody 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_healthbot_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, resource, **kwargs)  # noqa: E501
        else:
            (data) = self.update_healthbot_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, resource, **kwargs)  # noqa: E501
            return data

    def update_healthbot_topic_resource_resource_by_id_with_http_info(self, topic_name, resource_name, resource, **kwargs):  # noqa: E501
        """Overwrite a resource  # noqa: E501

        Overwrite a rule by the `resource-name`. The `resource-name` specified in URL and the request body must match.  # 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_topic_resource_resource_by_id_with_http_info(topic_name, resource_name, resource, 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 ResourceSchema resource: resourcebody object (required)
        :param str authorization: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['topic_name', 'resource_name', 'resource', '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_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 `update_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 `update_healthbot_topic_resource_resource_by_id`")  # noqa: E501
        # verify the required parameter 'resource' is set
        if ('resource' not in params or
                params['resource'] is None):
            raise ValueError("Missing the required parameter `resource` when calling `update_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 = []

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

        form_params = []
        local_var_files = {}

        body_params = None
        if 'resource' in params:
            body_params = params['resource']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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}/', '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_device_device_by_id(self, device_id, device, **kwargs):  # noqa: E501
        """Overwrite a device.  # noqa: E501

        Overwrite a device by device ID. The device ID specified in the URL and the request body must match.  # 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_device_device_by_id(device_id, device, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_id: ID of device-id (required)
        :param DeviceSchema device: devicebody 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_device_device_by_id_with_http_info(device_id, device, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_device_device_by_id_with_http_info(device_id, device, **kwargs)  # noqa: E501
            return data

    def update_iceberg_device_device_by_id_with_http_info(self, device_id, device, **kwargs):  # noqa: E501
        """Overwrite a device.  # noqa: E501

        Overwrite a device by device ID. The device ID specified in the URL and the request body must match.  # 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_device_device_by_id_with_http_info(device_id, device, async_req=True)
        >>> result = thread.get()

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

        all_params = ['device_id', 'device', '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_device_device_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 `update_iceberg_device_device_by_id`")  # noqa: E501
        # verify the required parameter 'device' is set
        if ('device' not in params or
                params['device'] is None):
            raise ValueError("Missing the required parameter `device` when calling `update_iceberg_device_device_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'device_id' in params:
            path_params['device_id'] = params['device_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 'device' in params:
            body_params = params['device']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/device/{device_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_iceberg_device_group_device_group_by_id(self, device_group_name, device_group, **kwargs):  # noqa: E501
        """Overwrite a device-group.  # noqa: E501

        Overwrite a device-group by its `device-group-name`. The `device-group-name` specified in the URL and the request body must match.  # 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_device_group_device_group_by_id(device_group_name, device_group, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str device_group_name: ID of device-group-name (required)
        :param DeviceGroupSchema device_group: device_groupbody 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_device_group_device_group_by_id_with_http_info(device_group_name, device_group, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_device_group_device_group_by_id_with_http_info(device_group_name, device_group, **kwargs)  # noqa: E501
            return data

    def update_iceberg_device_group_device_group_by_id_with_http_info(self, device_group_name, device_group, **kwargs):  # noqa: E501
        """Overwrite a device-group.  # noqa: E501

        Overwrite a device-group by its `device-group-name`. The `device-group-name` specified in the URL and the request body must match.  # 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_device_group_device_group_by_id_with_http_info(device_group_name, device_group, async_req=True)
        >>> result = thread.get()

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

        all_params = ['device_group_name', 'device_group', '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_device_group_device_group_by_id" % 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 `update_iceberg_device_group_device_group_by_id`")  # noqa: E501
        # verify the required parameter 'device_group' is set
        if ('device_group' not in params or
                params['device_group'] is None):
            raise ValueError("Missing the required parameter `device_group` when calling `update_iceberg_device_group_device_group_by_id`")  # 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 = []

        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 'device_group' in params:
            body_params = params['device_group']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/device-group/{device_group_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_device_groups_device_groups_by_id(self, device_groups, **kwargs):  # noqa: E501
        """Overwrite device-groups.  # noqa: E501

        Overwrite the existing configuration of device-groups. New device-groups are created and the existing device-groups are overwritten with new content. If some existing device-groups are not present in the payload, such device-groups are deleted. This will fail if any of the device-groups that are not present in the payload have running services.  # 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_device_groups_device_groups_by_id(device_groups, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeviceGroupsSchema device_groups: device-groupsbody 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_device_groups_device_groups_by_id_with_http_info(device_groups, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_device_groups_device_groups_by_id_with_http_info(device_groups, **kwargs)  # noqa: E501
            return data

    def update_iceberg_device_groups_device_groups_by_id_with_http_info(self, device_groups, **kwargs):  # noqa: E501
        """Overwrite device-groups.  # noqa: E501

        Overwrite the existing configuration of device-groups. New device-groups are created and the existing device-groups are overwritten with new content. If some existing device-groups are not present in the payload, such device-groups are deleted. This will fail if any of the device-groups that are not present in the payload have running services.  # 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_device_groups_device_groups_by_id_with_http_info(device_groups, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeviceGroupsSchema device_groups: device-groupsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['device_groups', '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_device_groups_device_groups_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'device_groups' is set
        if ('device_groups' not in params or
                params['device_groups'] is None):
            raise ValueError("Missing the required parameter `device_groups` when calling `update_iceberg_device_groups_device_groups_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 'device_groups' in params:
            body_params = params['device_groups']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/device-groups/', '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_devices_devices_by_id(self, devices, **kwargs):  # noqa: E501
        """Overwrite devices.  # noqa: E501

        Overwrite the existing configuration of devices. New devices are created and the existing devices are overwritten with new content. If some existing devices are not present in the payload, such devices are deleted. This will fail if any of the devices that are not present in the payload are referenced by 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.update_iceberg_devices_devices_by_id(devices, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DevicesSchema devices: devicesbody 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_devices_devices_by_id_with_http_info(devices, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_devices_devices_by_id_with_http_info(devices, **kwargs)  # noqa: E501
            return data

    def update_iceberg_devices_devices_by_id_with_http_info(self, devices, **kwargs):  # noqa: E501
        """Overwrite devices.  # noqa: E501

        Overwrite the existing configuration of devices. New devices are created and the existing devices are overwritten with new content. If some existing devices are not present in the payload, such devices are deleted. This will fail if any of the devices that are not present in the payload are referenced by 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.update_iceberg_devices_devices_by_id_with_http_info(devices, async_req=True)
        >>> result = thread.get()

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

        all_params = ['devices', '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_devices_devices_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'devices' is set
        if ('devices' not in params or
                params['devices'] is None):
            raise ValueError("Missing the required parameter `devices` when calling `update_iceberg_devices_devices_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 'devices' in params:
            body_params = params['devices']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/devices/', '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_network_group_network_group_by_id(self, network_group_name, network_group, **kwargs):  # noqa: E501
        """Overwrite a network-group.  # noqa: E501

        Overwrite a network-group by the `network-group-name`. The `network-group-name` specified in the URL and the request body must match.  # 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_network_group_network_group_by_id(network_group_name, network_group, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str network_group_name: ID of network-group-name (required)
        :param NetworkGroupSchema network_group: network_groupbody 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_network_group_network_group_by_id_with_http_info(network_group_name, network_group, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_network_group_network_group_by_id_with_http_info(network_group_name, network_group, **kwargs)  # noqa: E501
            return data

    def update_iceberg_network_group_network_group_by_id_with_http_info(self, network_group_name, network_group, **kwargs):  # noqa: E501
        """Overwrite a network-group.  # noqa: E501

        Overwrite a network-group by the `network-group-name`. The `network-group-name` specified in the URL and the request body must match.  # 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_network_group_network_group_by_id_with_http_info(network_group_name, network_group, async_req=True)
        >>> result = thread.get()

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

        all_params = ['network_group_name', 'network_group', '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_network_group_network_group_by_id" % 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 `update_iceberg_network_group_network_group_by_id`")  # noqa: E501
        # verify the required parameter 'network_group' is set
        if ('network_group' not in params or
                params['network_group'] is None):
            raise ValueError("Missing the required parameter `network_group` when calling `update_iceberg_network_group_network_group_by_id`")  # 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 = []

        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 'network_group' in params:
            body_params = params['network_group']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/network-group/{network_group_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_network_groups_network_groups_by_id(self, network_groups, **kwargs):  # noqa: E501
        """Overwrite network-groups.  # noqa: E501

        Overwrite the existing network-group configuration. New network-groups are created and the existing network-groups are overwritten with new content. If some of the existing network-groups are not present in the payload, such network-groups are deleted. This will fail if any of the network-groups that are not present in the payload have running services.  # 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_network_groups_network_groups_by_id(network_groups, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NetworkGroupsSchema network_groups: network-groupsbody 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_network_groups_network_groups_by_id_with_http_info(network_groups, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_network_groups_network_groups_by_id_with_http_info(network_groups, **kwargs)  # noqa: E501
            return data

    def update_iceberg_network_groups_network_groups_by_id_with_http_info(self, network_groups, **kwargs):  # noqa: E501
        """Overwrite network-groups.  # noqa: E501

        Overwrite the existing network-group configuration. New network-groups are created and the existing network-groups are overwritten with new content. If some of the existing network-groups are not present in the payload, such network-groups are deleted. This will fail if any of the network-groups that are not present in the payload have running services.  # 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_network_groups_network_groups_by_id_with_http_info(network_groups, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NetworkGroupsSchema network_groups: network-groupsbody object (required)
        :param str x_iam_token: authentication header object
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['network_groups', '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_network_groups_network_groups_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'network_groups' is set
        if ('network_groups' not in params or
                params['network_groups'] is None):
            raise ValueError("Missing the required parameter `network_groups` when calling `update_iceberg_network_groups_network_groups_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 'network_groups' in params:
            body_params = params['network_groups']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/network-groups/', '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_notification_notification_by_id(self, notification_name, notification, **kwargs):  # noqa: E501
        """Overwrite a notification.  # noqa: E501

        Overwrite a notification by the `notification-name`. The `notification-name` specified in URL and the request body must match.  # 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_notification_notification_by_id(notification_name, notification, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str notification_name: ID of notification-name (required)
        :param NotificationSchema notification: notificationbody 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_notification_notification_by_id_with_http_info(notification_name, notification, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_notification_notification_by_id_with_http_info(notification_name, notification, **kwargs)  # noqa: E501
            return data

    def update_iceberg_notification_notification_by_id_with_http_info(self, notification_name, notification, **kwargs):  # noqa: E501
        """Overwrite a notification.  # noqa: E501

        Overwrite a notification by the `notification-name`. The `notification-name` specified in URL and the request body must match.  # 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_notification_notification_by_id_with_http_info(notification_name, notification, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'notification_name' in params:
            path_params['notification_name'] = params['notification_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 'notification' in params:
            body_params = params['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/notification/{notification_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_notifications_notifications_by_id(self, notifications, **kwargs):  # noqa: E501
        """Overwrite notifications.  # noqa: E501

        Overwrite the existing notifications configuration. New notifications are created and existing notifications are overwritten with new content. If some of the existing notifications are not present in the payload, such notifications are deleted. This will fail if any of the notifications that are not present in the payload are referenced by 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.update_iceberg_notifications_notifications_by_id(notifications, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param NotificationsSchema notifications: notificationsbody 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_notifications_notifications_by_id_with_http_info(notifications, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_notifications_notifications_by_id_with_http_info(notifications, **kwargs)  # noqa: E501
            return data

    def update_iceberg_notifications_notifications_by_id_with_http_info(self, notifications, **kwargs):  # noqa: E501
        """Overwrite notifications.  # noqa: E501

        Overwrite the existing notifications configuration. New notifications are created and existing notifications are overwritten with new content. If some of the existing notifications are not present in the payload, such notifications are deleted. This will fail if any of the notifications that are not present in the payload are referenced by 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.update_iceberg_notifications_notifications_by_id_with_http_info(notifications, async_req=True)
        >>> result = thread.get()

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

        all_params = ['notifications', '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_notifications_notifications_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'notifications' is set
        if ('notifications' not in params or
                params['notifications'] is None):
            raise ValueError("Missing the required parameter `notifications` when calling `update_iceberg_notifications_notifications_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 'notifications' in params:
            body_params = params['notifications']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/notifications/', '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_playbook_playbook_by_id(self, playbook_name, playbook, **kwargs):  # noqa: E501
        """Overwrite a playbook.  # noqa: E501

        Overwrite a playbook by the `playbook-name`. The `playbook-name` specified in the URL and the request body must match.  # 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_playbook_playbook_by_id(playbook_name, playbook, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str playbook_name: ID of playbook-name (required)
        :param PlaybookSchema playbook: playbookbody 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_playbook_playbook_by_id_with_http_info(playbook_name, playbook, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_playbook_playbook_by_id_with_http_info(playbook_name, playbook, **kwargs)  # noqa: E501
            return data

    def update_iceberg_playbook_playbook_by_id_with_http_info(self, playbook_name, playbook, **kwargs):  # noqa: E501
        """Overwrite a playbook.  # noqa: E501

        Overwrite a playbook by the `playbook-name`. The `playbook-name` specified in the URL and the request body must match.  # 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_playbook_playbook_by_id_with_http_info(playbook_name, playbook, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'playbook_name' in params:
            path_params['playbook_name'] = params['playbook_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 'playbook' in params:
            body_params = params['playbook']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/playbook/{playbook_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_playbooks_playbooks_by_id(self, playbooks, **kwargs):  # noqa: E501
        """Overwrite all playbooks.  # noqa: E501

        Overwrite the existing playbooks configuration. New playbooks are created and existing playbooks are overwritten with new content. If some of the existing playbooks are not present in the payload, such playbooks are deleted. This will fail if any of the playbooks that are not present in the payload are referenced by 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.update_iceberg_playbooks_playbooks_by_id(playbooks, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param PlaybooksSchema playbooks: playbooksbody 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_playbooks_playbooks_by_id_with_http_info(playbooks, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_playbooks_playbooks_by_id_with_http_info(playbooks, **kwargs)  # noqa: E501
            return data

    def update_iceberg_playbooks_playbooks_by_id_with_http_info(self, playbooks, **kwargs):  # noqa: E501
        """Overwrite all playbooks.  # noqa: E501

        Overwrite the existing playbooks configuration. New playbooks are created and existing playbooks are overwritten with new content. If some of the existing playbooks are not present in the payload, such playbooks are deleted. This will fail if any of the playbooks that are not present in the payload are referenced by 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.update_iceberg_playbooks_playbooks_by_id_with_http_info(playbooks, async_req=True)
        >>> result = thread.get()

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

        all_params = ['playbooks', '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_playbooks_playbooks_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'playbooks' is set
        if ('playbooks' not in params or
                params['playbooks'] is None):
            raise ValueError("Missing the required parameter `playbooks` when calling `update_iceberg_playbooks_playbooks_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 'playbooks' in params:
            body_params = params['playbooks']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/playbooks/', '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_retention_policies_retention_policies_id(self, retention_policies, **kwargs):  # noqa: E501
        """Overwrite all retention-policies.  # noqa: E501

        Overwrite the existing retention-policies configuration. New retention-policies are created and existing retention-policies are overwritten with new content. If some existing retention-policies are not present in the payload, such retention-policies are deleted. This will fail if any of the retention-policies that are not present in the payload are referenced by 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.update_iceberg_retention_policies_retention_policies_id(retention_policies, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RetentionPoliciesSchema retention_policies: retention-policies 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_iceberg_retention_policies_retention_policies_id_with_http_info(retention_policies, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_retention_policies_retention_policies_id_with_http_info(retention_policies, **kwargs)  # noqa: E501
            return data

    def update_iceberg_retention_policies_retention_policies_id_with_http_info(self, retention_policies, **kwargs):  # noqa: E501
        """Overwrite all retention-policies.  # noqa: E501

        Overwrite the existing retention-policies configuration. New retention-policies are created and existing retention-policies are overwritten with new content. If some existing retention-policies are not present in the payload, such retention-policies are deleted. This will fail if any of the retention-policies that are not present in the payload are referenced by 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.update_iceberg_retention_policies_retention_policies_id_with_http_info(retention_policies, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RetentionPoliciesSchema retention_policies: retention-policies 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 = ['retention_policies', '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_retention_policies_retention_policies_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'retention_policies' is set
        if ('retention_policies' not in params or
                params['retention_policies'] is None):
            raise ValueError("Missing the required parameter `retention_policies` when calling `update_iceberg_retention_policies_retention_policies_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 'retention_policies' in params:
            body_params = params['retention_policies']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/retention-policies/', '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_retention_policy_retention_policy_by_id(self, retention_policy_name, retention_policy, **kwargs):  # noqa: E501
        """Overwrite a retention-policy.  # noqa: E501

        Overwrite a retention-policy by the `retention-policy-name`. The `retention-policy-name` specified in URL and the request body must match.  # 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_retention_policy_retention_policy_by_id(retention_policy_name, retention_policy, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str retention_policy_name: ID of retention-policy-name (required)
        :param RetentionPolicySchema retention_policy: retention_policybody 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_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, retention_policy, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, retention_policy, **kwargs)  # noqa: E501
            return data

    def update_iceberg_retention_policy_retention_policy_by_id_with_http_info(self, retention_policy_name, retention_policy, **kwargs):  # noqa: E501
        """Overwrite a retention-policy.  # noqa: E501

        Overwrite a retention-policy by the `retention-policy-name`. The `retention-policy-name` specified in URL and the request body must match.  # 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_retention_policy_retention_policy_by_id_with_http_info(retention_policy_name, retention_policy, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'retention_policy_name' in params:
            path_params['retention_policy_name'] = params['retention_policy_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 'retention_policy' in params:
            body_params = params['retention_policy']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/retention-policy/{retention_policy_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_system_destination_by_id(self, name, destination, **kwargs):  # noqa: E501
        """Update destination by name  # noqa: E501

        Overwrite a destination by destination name. The destination name specified in the URL and the request body must match.  # 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_system_destination_by_id(name, destination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param DestinationSchema destination: destinationsbody 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_system_destination_by_id_with_http_info(name, destination, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_destination_by_id_with_http_info(name, destination, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_destination_by_id_with_http_info(self, name, destination, **kwargs):  # noqa: E501
        """Update destination by name  # noqa: E501

        Overwrite a destination by destination name. The destination name specified in the URL and the request body must match.  # 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_system_destination_by_id_with_http_info(name, destination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param DestinationSchema destination: destinationsbody 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', 'destination', '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_system_destination_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_system_destination_by_id`")  # noqa: E501
        # verify the required parameter 'destination' is set
        if ('destination' not in params or
                params['destination'] is None):
            raise ValueError("Missing the required parameter `destination` when calling `update_iceberg_system_destination_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 'destination' in params:
            body_params = params['destination']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/report-generation/destination/{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_system_destinations(self, destinations, **kwargs):  # noqa: E501
        """Update destinations by name  # noqa: E501

        Overwrite the existing configuration of destinations. New destinations are created and the existing destinations are overwritten with new content. If some existing destinations are not present in the payload, such destinations are deleted. This will fail if any of the destinations that are not present in the payload are referenced by a report.  # 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_system_destinations(destinations, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DestinationsSchema destinations: destinationsbody 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_system_destinations_with_http_info(destinations, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_destinations_with_http_info(destinations, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_destinations_with_http_info(self, destinations, **kwargs):  # noqa: E501
        """Update destinations by name  # noqa: E501

        Overwrite the existing configuration of destinations. New destinations are created and the existing destinations are overwritten with new content. If some existing destinations are not present in the payload, such destinations are deleted. This will fail if any of the destinations that are not present in the payload are referenced by a report.  # 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_system_destinations_with_http_info(destinations, async_req=True)
        >>> result = thread.get()

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

        all_params = ['destinations', '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_system_destinations" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'destinations' is set
        if ('destinations' not in params or
                params['destinations'] is None):
            raise ValueError("Missing the required parameter `destinations` when calling `update_iceberg_system_destinations`")  # 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 'destinations' in params:
            body_params = params['destinations']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/report-generation/destinations/', '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_system_report_by_id(self, name, report, **kwargs):  # noqa: E501
        """Update report by name  # noqa: E501

        Overwrite a report by report name. The report name specified in the URL and the request body must match.  # 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_system_report_by_id(name, report, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param ReportSchema report: reportsbody 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_system_report_by_id_with_http_info(name, report, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_report_by_id_with_http_info(name, report, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_report_by_id_with_http_info(self, name, report, **kwargs):  # noqa: E501
        """Update report by name  # noqa: E501

        Overwrite a report by report name. The report name specified in the URL and the request body must match.  # 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_system_report_by_id_with_http_info(name, report, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param ReportSchema report: reportsbody 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', 'report', '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_system_report_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_system_report_by_id`")  # noqa: E501
        # verify the required parameter 'report' is set
        if ('report' not in params or
                params['report'] is None):
            raise ValueError("Missing the required parameter `report` when calling `update_iceberg_system_report_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 'report' in params:
            body_params = params['report']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/report-generation/report/{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_system_reports(self, reports, **kwargs):  # noqa: E501
        """Update reports by name  # noqa: E501

        Overwrite the existing configuration of reports. New reports are created and the existing reports are overwritten with new content. If some existing reports are not present in the payload, such reports are deleted. This will fail if any of the reports that are not present in the payload are referenced by a device-group or 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.update_iceberg_system_reports(reports, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReportsSchema reports: reportsbody 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_system_reports_with_http_info(reports, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_reports_with_http_info(reports, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_reports_with_http_info(self, reports, **kwargs):  # noqa: E501
        """Update reports by name  # noqa: E501

        Overwrite the existing configuration of reports. New reports are created and the existing reports are overwritten with new content. If some existing reports are not present in the payload, such reports are deleted. This will fail if any of the reports that are not present in the payload are referenced by a device-group or 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.update_iceberg_system_reports_with_http_info(reports, async_req=True)
        >>> result = thread.get()

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

        all_params = ['reports', '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_system_reports" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'reports' is set
        if ('reports' not in params or
                params['reports'] is None):
            raise ValueError("Missing the required parameter `reports` when calling `update_iceberg_system_reports`")  # 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 'reports' in params:
            body_params = params['reports']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/report-generation/reports/', '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_system_scheduler_by_id(self, name, scheduler, **kwargs):  # noqa: E501
        """Update scheduler by name  # noqa: E501

        Overwrite a scheduler by scheduler name. The scheduler name specified in the URL and the request body must match.  # 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_system_scheduler_by_id(name, scheduler, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param SchedulerSchema scheduler: schedulerbody 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_system_scheduler_by_id_with_http_info(name, scheduler, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_scheduler_by_id_with_http_info(name, scheduler, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_scheduler_by_id_with_http_info(self, name, scheduler, **kwargs):  # noqa: E501
        """Update scheduler by name  # noqa: E501

        Overwrite a scheduler by scheduler name. The scheduler name specified in the URL and the request body must match.  # 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_system_scheduler_by_id_with_http_info(name, scheduler, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param SchedulerSchema scheduler: schedulerbody 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', 'scheduler', '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_system_scheduler_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_system_scheduler_by_id`")  # noqa: E501
        # verify the required parameter 'scheduler' is set
        if ('scheduler' not in params or
                params['scheduler'] is None):
            raise ValueError("Missing the required parameter `scheduler` when calling `update_iceberg_system_scheduler_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 'scheduler' in params:
            body_params = params['scheduler']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/scheduler/{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_system_schedulers(self, schedulers, **kwargs):  # noqa: E501
        """Update schedulers by name  # noqa: E501

        Update operation of resource: schedulers  # 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_system_schedulers(schedulers, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SchedulersSchema schedulers: schedulersbody 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_system_schedulers_with_http_info(schedulers, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_schedulers_with_http_info(schedulers, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_schedulers_with_http_info(self, schedulers, **kwargs):  # noqa: E501
        """Update schedulers by name  # noqa: E501

        Update operation of resource: schedulers  # 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_system_schedulers_with_http_info(schedulers, async_req=True)
        >>> result = thread.get()

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

        all_params = ['schedulers', '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_system_schedulers" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'schedulers' is set
        if ('schedulers' not in params or
                params['schedulers'] is None):
            raise ValueError("Missing the required parameter `schedulers` when calling `update_iceberg_system_schedulers`")  # 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 'schedulers' in params:
            body_params = params['schedulers']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/schedulers/', '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_system_settings_destination_by_id(self, name, destination, **kwargs):  # noqa: E501
        """Update destination by name  # noqa: E501

        Overwrite a destination by destination name. The destination name specified in the URL and the request body must match.  # 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_system_settings_destination_by_id(name, destination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param DestinationSchema destination: destinationsbody 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_system_settings_destination_by_id_with_http_info(name, destination, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_settings_destination_by_id_with_http_info(name, destination, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_settings_destination_by_id_with_http_info(self, name, destination, **kwargs):  # noqa: E501
        """Update destination by name  # noqa: E501

        Overwrite a destination by destination name. The destination name specified in the URL and the request body must match.  # 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_system_settings_destination_by_id_with_http_info(name, destination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of destination (required)
        :param DestinationSchema destination: destinationsbody 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', 'destination', '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_system_settings_destination_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_system_settings_destination_by_id`")  # noqa: E501
        # verify the required parameter 'destination' is set
        if ('destination' not in params or
                params['destination'] is None):
            raise ValueError("Missing the required parameter `destination` when calling `update_iceberg_system_settings_destination_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 'destination' in params:
            body_params = params['destination']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/report-generation/destination/{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_system_settings_destinations(self, destinations, **kwargs):  # noqa: E501
        """Update destinations by name  # noqa: E501

        Overwrite the existing configuration of destinations. New destinations are created and the existing destinations are overwritten with new content. If some existing destinations are not present in the payload, such destinations are deleted. This will fail if any of the destinations that are not present in the payload are referenced by a report.  # 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_system_settings_destinations(destinations, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DestinationsSchema destinations: destinationsbody 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_system_settings_destinations_with_http_info(destinations, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_settings_destinations_with_http_info(destinations, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_settings_destinations_with_http_info(self, destinations, **kwargs):  # noqa: E501
        """Update destinations by name  # noqa: E501

        Overwrite the existing configuration of destinations. New destinations are created and the existing destinations are overwritten with new content. If some existing destinations are not present in the payload, such destinations are deleted. This will fail if any of the destinations that are not present in the payload are referenced by a report.  # 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_system_settings_destinations_with_http_info(destinations, async_req=True)
        >>> result = thread.get()

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

        all_params = ['destinations', '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_system_settings_destinations" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'destinations' is set
        if ('destinations' not in params or
                params['destinations'] is None):
            raise ValueError("Missing the required parameter `destinations` when calling `update_iceberg_system_settings_destinations`")  # 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 'destinations' in params:
            body_params = params['destinations']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/report-generation/destinations/', '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_system_settings_report_by_id(self, name, report, **kwargs):  # noqa: E501
        """Update report by name  # noqa: E501

        Overwrite a report by report name. The report name specified in the URL and the request body must match.  # 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_system_settings_report_by_id(name, report, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param ReportSchema report: reportsbody 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_system_settings_report_by_id_with_http_info(name, report, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_settings_report_by_id_with_http_info(name, report, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_settings_report_by_id_with_http_info(self, name, report, **kwargs):  # noqa: E501
        """Update report by name  # noqa: E501

        Overwrite a report by report name. The report name specified in the URL and the request body must match.  # 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_system_settings_report_by_id_with_http_info(name, report, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of report (required)
        :param ReportSchema report: reportsbody 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', 'report', '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_system_settings_report_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_system_settings_report_by_id`")  # noqa: E501
        # verify the required parameter 'report' is set
        if ('report' not in params or
                params['report'] is None):
            raise ValueError("Missing the required parameter `report` when calling `update_iceberg_system_settings_report_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 'report' in params:
            body_params = params['report']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/report-generation/report/{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_system_settings_reports(self, reports, **kwargs):  # noqa: E501
        """Update reports by name  # noqa: E501

        Overwrite the existing configuration of reports. New reports are created and the existing reports are overwritten with new content. If some existing reports are not present in the payload, such reports are deleted. This will fail if any of the reports that are not present in the payload are referenced by a device-group or 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.update_iceberg_system_settings_reports(reports, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReportsSchema reports: reportsbody 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_system_settings_reports_with_http_info(reports, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_settings_reports_with_http_info(reports, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_settings_reports_with_http_info(self, reports, **kwargs):  # noqa: E501
        """Update reports by name  # noqa: E501

        Overwrite the existing configuration of reports. New reports are created and the existing reports are overwritten with new content. If some existing reports are not present in the payload, such reports are deleted. This will fail if any of the reports that are not present in the payload are referenced by a device-group or 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.update_iceberg_system_settings_reports_with_http_info(reports, async_req=True)
        >>> result = thread.get()

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

        all_params = ['reports', '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_system_settings_reports" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'reports' is set
        if ('reports' not in params or
                params['reports'] is None):
            raise ValueError("Missing the required parameter `reports` when calling `update_iceberg_system_settings_reports`")  # 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 'reports' in params:
            body_params = params['reports']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/report-generation/reports/', '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_system_settings_scheduler_by_id(self, name, scheduler, **kwargs):  # noqa: E501
        """Update scheduler by name  # noqa: E501

        Overwrite a scheduler by scheduler name. The scheduler name specified in the URL and the request body must match.  # 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_system_settings_scheduler_by_id(name, scheduler, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param SchedulerSchema scheduler: schedulerbody 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_system_settings_scheduler_by_id_with_http_info(name, scheduler, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_settings_scheduler_by_id_with_http_info(name, scheduler, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_settings_scheduler_by_id_with_http_info(self, name, scheduler, **kwargs):  # noqa: E501
        """Update scheduler by name  # noqa: E501

        Overwrite a scheduler by scheduler name. The scheduler name specified in the URL and the request body must match.  # 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_system_settings_scheduler_by_id_with_http_info(name, scheduler, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str name: Name of Scheduler (required)
        :param SchedulerSchema scheduler: schedulerbody 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', 'scheduler', '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_system_settings_scheduler_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_system_settings_scheduler_by_id`")  # noqa: E501
        # verify the required parameter 'scheduler' is set
        if ('scheduler' not in params or
                params['scheduler'] is None):
            raise ValueError("Missing the required parameter `scheduler` when calling `update_iceberg_system_settings_scheduler_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 'scheduler' in params:
            body_params = params['scheduler']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/scheduler/{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_system_settings_schedulers(self, schedulers, **kwargs):  # noqa: E501
        """Update schedulers by name  # noqa: E501

        Update operation of resource: schedulers  # 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_system_settings_schedulers(schedulers, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SchedulersSchema schedulers: schedulersbody 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_system_settings_schedulers_with_http_info(schedulers, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_settings_schedulers_with_http_info(schedulers, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_settings_schedulers_with_http_info(self, schedulers, **kwargs):  # noqa: E501
        """Update schedulers by name  # noqa: E501

        Update operation of resource: schedulers  # 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_system_settings_schedulers_with_http_info(schedulers, async_req=True)
        >>> result = thread.get()

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

        all_params = ['schedulers', '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_system_settings_schedulers" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'schedulers' is set
        if ('schedulers' not in params or
                params['schedulers'] is None):
            raise ValueError("Missing the required parameter `schedulers` when calling `update_iceberg_system_settings_schedulers`")  # 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 'schedulers' in params:
            body_params = params['schedulers']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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-settings/schedulers/', '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_system_settings_system_settings_by_id(self, system_settings, **kwargs):  # noqa: E501
        """Update system-settings by ID  # noqa: E501

        Overwrite the existing configuration of system-settings. New system-settings are created and existing system-settings are overwritten with new content. If some existing system-settings are not present in the payload, such system-settings are deleted. This will fail if any of the reports in system-settings that are not present in the payload are referenced by a device-group or 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.update_iceberg_system_settings_system_settings_by_id(system_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SystemSettingsSchema system_settings: system_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :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_iceberg_system_settings_system_settings_by_id_with_http_info(system_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_settings_system_settings_by_id_with_http_info(system_settings, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_settings_system_settings_by_id_with_http_info(self, system_settings, **kwargs):  # noqa: E501
        """Update system-settings by ID  # noqa: E501

        Overwrite the existing configuration of system-settings. New system-settings are created and existing system-settings are overwritten with new content. If some existing system-settings are not present in the payload, such system-settings are deleted. This will fail if any of the reports in system-settings that are not present in the payload are referenced by a device-group or 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.update_iceberg_system_settings_system_settings_by_id_with_http_info(system_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SystemSettingsSchema system_settings: system_settingsbody object (required)
        :param str x_iam_token: authentication header object
        :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 = ['system_settings', 'x_iam_token', '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_iceberg_system_settings_system_settings_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'system_settings' is set
        if ('system_settings' not in params or
                params['system_settings'] is None):
            raise ValueError("Missing the required parameter `system_settings` when calling `update_iceberg_system_settings_system_settings_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 = {}
        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 'system_settings' in params:
            body_params = params['system_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/system-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_system_system_by_id(self, system_settings, **kwargs):  # noqa: E501
        """Update system by ID  # noqa: E501

        New endpoint to over-write the existing configuration of system-settings. New system-settings are created and existing system-settings are overwritten with new content. If some existing system-settings are not present in the payload, such system settings are deleted. This will fail if any of the reports in system-settings that are not present in the payload are referenced by a device-group or 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.update_iceberg_system_system_by_id(system_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SystemSettingsSchema system_settings: system_settings body object (required)
        :param str x_iam_token: authentication header object
        :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_iceberg_system_system_by_id_with_http_info(system_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_system_system_by_id_with_http_info(system_settings, **kwargs)  # noqa: E501
            return data

    def update_iceberg_system_system_by_id_with_http_info(self, system_settings, **kwargs):  # noqa: E501
        """Update system by ID  # noqa: E501

        New endpoint to over-write the existing configuration of system-settings. New system-settings are created and existing system-settings are overwritten with new content. If some existing system-settings are not present in the payload, such system settings are deleted. This will fail if any of the reports in system-settings that are not present in the payload are referenced by a device-group or 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.update_iceberg_system_system_by_id_with_http_info(system_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SystemSettingsSchema system_settings: system_settings body object (required)
        :param str x_iam_token: authentication header object
        :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 = ['system_settings', 'x_iam_token', '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_iceberg_system_system_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'system_settings' is set
        if ('system_settings' not in params or
                params['system_settings'] is None):
            raise ValueError("Missing the required parameter `system_settings` when calling `update_iceberg_system_system_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 = {}
        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 'system_settings' in params:
            body_params = params['system_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/system/', '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_topic_rule_rule_by_id(self, topic_name, rule_name, rule, **kwargs):  # noqa: E501
        """Overwrite a rule.  # noqa: E501

        Overwrite a rule by the `rule-name`. The `rule-name` specified in URL and the request body must match.  # 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_topic_rule_rule_by_id(topic_name, rule_name, rule, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param str rule_name: ID of rule-name (required)
        :param RuleSchema rule: rulebody 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_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, rule, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, rule, **kwargs)  # noqa: E501
            return data

    def update_iceberg_topic_rule_rule_by_id_with_http_info(self, topic_name, rule_name, rule, **kwargs):  # noqa: E501
        """Overwrite a rule.  # noqa: E501

        Overwrite a rule by the `rule-name`. The `rule-name` specified in URL and the request body must match.  # 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_topic_rule_rule_by_id_with_http_info(topic_name, rule_name, rule, async_req=True)
        >>> result = thread.get()

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

        all_params = ['topic_name', 'rule_name', 'rule', '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_topic_rule_rule_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 `update_iceberg_topic_rule_rule_by_id`")  # noqa: E501
        # verify the required parameter 'rule_name' is set
        if ('rule_name' not in params or
                params['rule_name'] is None):
            raise ValueError("Missing the required parameter `rule_name` when calling `update_iceberg_topic_rule_rule_by_id`")  # noqa: E501
        # verify the required parameter 'rule' is set
        if ('rule' not in params or
                params['rule'] is None):
            raise ValueError("Missing the required parameter `rule` when calling `update_iceberg_topic_rule_rule_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_name']  # noqa: E501
        if 'rule_name' in params:
            path_params['rule_name'] = params['rule_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 'rule' in params:
            body_params = params['rule']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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}/rule/{rule_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_topic_topic_by_id(self, topic_name, topic, **kwargs):  # noqa: E501
        """Overwrite a topic.  # noqa: E501

        Overwrite a topic by the `topic-name`. The `topic-name` specified in URL and the request body must match.  # 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_topic_topic_by_id(topic_name, topic, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str topic_name: ID of topic-name (required)
        :param TopicSchema topic: topicbody 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_topic_topic_by_id_with_http_info(topic_name, topic, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_topic_topic_by_id_with_http_info(topic_name, topic, **kwargs)  # noqa: E501
            return data

    def update_iceberg_topic_topic_by_id_with_http_info(self, topic_name, topic, **kwargs):  # noqa: E501
        """Overwrite a topic.  # noqa: E501

        Overwrite a topic by the `topic-name`. The `topic-name` specified in URL and the request body must match.  # 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_topic_topic_by_id_with_http_info(topic_name, topic, async_req=True)
        >>> result = thread.get()

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

        all_params = ['topic_name', 'topic', '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_topic_topic_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 `update_iceberg_topic_topic_by_id`")  # noqa: E501
        # verify the required parameter 'topic' is set
        if ('topic' not in params or
                params['topic'] is None):
            raise ValueError("Missing the required parameter `topic` when calling `update_iceberg_topic_topic_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'topic_name' in params:
            path_params['topic_name'] = params['topic_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 'topic' in params:
            body_params = params['topic']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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}/', '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_topics_topics_by_id(self, topics, **kwargs):  # noqa: E501
        """Overwrite topics.  # noqa: E501

        Overwrite the existing topics configuration. New topics are created and existing topics are overwritten with new content. If some existing topics are not present in the payload, such topics are deleted. This will fail if any of the topics that are not present in the payload are referenced by a playbook.  # 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_topics_topics_by_id(topics, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TopicsSchema topics: topicsbody 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_topics_topics_by_id_with_http_info(topics, **kwargs)  # noqa: E501
        else:
            (data) = self.update_iceberg_topics_topics_by_id_with_http_info(topics, **kwargs)  # noqa: E501
            return data

    def update_iceberg_topics_topics_by_id_with_http_info(self, topics, **kwargs):  # noqa: E501
        """Overwrite topics.  # noqa: E501

        Overwrite the existing topics configuration. New topics are created and existing topics are overwritten with new content. If some existing topics are not present in the payload, such topics are deleted. This will fail if any of the topics that are not present in the payload are referenced by a playbook.  # 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_topics_topics_by_id_with_http_info(topics, async_req=True)
        >>> result = thread.get()

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

        all_params = ['topics', '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_topics_topics_by_id" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'topics' is set
        if ('topics' not in params or
                params['topics'] is None):
            raise ValueError("Missing the required parameter `topics` when calling `update_iceberg_topics_topics_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 'topics' in params:
            body_params = params['topics']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP 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/topics/', '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)
