# coding: utf-8

"""
    Collibra Data Governance Center Core API

    <p>The Core REST API allows you to create your own integrations with Collibra Data Governance Center.</p><p><i>Create custom applications to help users get access to the right data.</i></p>  # noqa: E501

    OpenAPI spec version: 2.0
    
    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 collibra_core.api_client import ApiClient


class DomainTypesApi(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 add_domain_type(self, **kwargs):  # noqa: E501
        """Adds a new domain type.  # noqa: E501

        Adds a new domain type.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_domain_type(async_req=True)
        >>> result = thread.get()

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

    def add_domain_type_with_http_info(self, **kwargs):  # noqa: E501
        """Adds a new domain type.  # noqa: E501

        Adds a new domain type.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_domain_type_with_http_info(async_req=True)
        >>> result = thread.get()

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

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DomainTypeImpl',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_domain_types(self, **kwargs):  # noqa: E501
        """Adds multiple new domain types.  # noqa: E501

        Adds multiple new domain types.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_domain_types(async_req=True)
        >>> result = thread.get()

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

    def add_domain_types_with_http_info(self, **kwargs):  # noqa: E501
        """Adds multiple new domain types.  # noqa: E501

        Adds multiple new domain types.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_domain_types_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[AddDomainTypeRequest] body:
        :return: list[DomainTypeImpl]
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes/bulk', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DomainTypeImpl]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def change_domain_type(self, domain_type_id, **kwargs):  # noqa: E501
        """Changes the domain type.  # noqa: E501

        Changes the domain type with the information present in the request. Only properties that are specified in this request and have not <code>null</code> values are updated. All other properties are ignored.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_domain_type(domain_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str domain_type_id: the unique identifier of the domain type (required)
        :param ChangeDomainTypeRequest body:
        :return: DomainTypeImpl
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.change_domain_type_with_http_info(domain_type_id, **kwargs)  # noqa: E501
        else:
            (data) = self.change_domain_type_with_http_info(domain_type_id, **kwargs)  # noqa: E501
            return data

    def change_domain_type_with_http_info(self, domain_type_id, **kwargs):  # noqa: E501
        """Changes the domain type.  # noqa: E501

        Changes the domain type with the information present in the request. Only properties that are specified in this request and have not <code>null</code> values are updated. All other properties are ignored.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_domain_type_with_http_info(domain_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str domain_type_id: the unique identifier of the domain type (required)
        :param ChangeDomainTypeRequest body:
        :return: DomainTypeImpl
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes/{domainTypeId}', 'PATCH',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DomainTypeImpl',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def change_domain_types(self, **kwargs):  # noqa: E501
        """Changes the domain types.  # noqa: E501

        Changes the domain types with the information present in the request.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_domain_types(async_req=True)
        >>> result = thread.get()

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

    def change_domain_types_with_http_info(self, **kwargs):  # noqa: E501
        """Changes the domain types.  # noqa: E501

        Changes the domain types with the information present in the request.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_domain_types_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[ChangeDomainTypeRequest] body:
        :return: list[DomainTypeImpl]
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes/bulk', 'PATCH',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DomainTypeImpl]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def find_domain_types(self, **kwargs):  # noqa: E501
        """Returns domain types matching the given search criteria.  # noqa: E501

        Returns domain types matching the given search criteria. Only parameters that are specified in this request and have not <code>null</code> values are used for filtering. All other parameters are ignored. The returned domain types satisfy all constraints that are specified in this search criteria. By default a result containing 1000 domain types is returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.find_domain_types(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param int offset: The first result to retrieve. If not set (offset = <code>0</code>), results will be retrieved starting from row <code>0</code>.
        :param int limit: The maximum number of results to retrieve. If not set (limit = <code>0</code>), the default limit will be used. The maximum allowed limit is 1000.
        :param int count_limit: Allows to limit the number of elements that will be counted. -1 will count everything and 0 will cause the count to be skipped
        :param str name: The name of the Domain Type to search for.
        :param str name_match_mode: The match mode used to compare <code>name</code>. The search is case-insensitive.
        :param str parent_id: The ID of the parent to find the Domain Types in.
        :param bool exclude_meta: Whether the meta Domain Types should be excluded from search or not.
        :param bool top_level: Whether only top level Domain Types should be searched or not.
        :return: DomainTypePagedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.find_domain_types_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.find_domain_types_with_http_info(**kwargs)  # noqa: E501
            return data

    def find_domain_types_with_http_info(self, **kwargs):  # noqa: E501
        """Returns domain types matching the given search criteria.  # noqa: E501

        Returns domain types matching the given search criteria. Only parameters that are specified in this request and have not <code>null</code> values are used for filtering. All other parameters are ignored. The returned domain types satisfy all constraints that are specified in this search criteria. By default a result containing 1000 domain types is returned.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.find_domain_types_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param int offset: The first result to retrieve. If not set (offset = <code>0</code>), results will be retrieved starting from row <code>0</code>.
        :param int limit: The maximum number of results to retrieve. If not set (limit = <code>0</code>), the default limit will be used. The maximum allowed limit is 1000.
        :param int count_limit: Allows to limit the number of elements that will be counted. -1 will count everything and 0 will cause the count to be skipped
        :param str name: The name of the Domain Type to search for.
        :param str name_match_mode: The match mode used to compare <code>name</code>. The search is case-insensitive.
        :param str parent_id: The ID of the parent to find the Domain Types in.
        :param bool exclude_meta: Whether the meta Domain Types should be excluded from search or not.
        :param bool top_level: Whether only top level Domain Types should be searched or not.
        :return: DomainTypePagedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['offset', 'limit', 'count_limit', 'name', 'name_match_mode', 'parent_id', 'exclude_meta', 'top_level']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'offset' in params:
            query_params.append(('offset', params['offset']))  # noqa: E501
        if 'limit' in params:
            query_params.append(('limit', params['limit']))  # noqa: E501
        if 'count_limit' in params:
            query_params.append(('countLimit', params['count_limit']))  # noqa: E501
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501
        if 'name_match_mode' in params:
            query_params.append(('nameMatchMode', params['name_match_mode']))  # noqa: E501
        if 'parent_id' in params:
            query_params.append(('parentId', params['parent_id']))  # noqa: E501
        if 'exclude_meta' in params:
            query_params.append(('excludeMeta', params['exclude_meta']))  # noqa: E501
        if 'top_level' in params:
            query_params.append(('topLevel', params['top_level']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DomainTypePagedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def find_sub_domain_types(self, domain_type_id, **kwargs):  # noqa: E501
        """Returns sub domain types matching the given search criteria.  # noqa: E501

        Returns sub domain types matching the given search criteria.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.find_sub_domain_types(domain_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str domain_type_id: the unique identifier of the domain type (required)
        :param str domain_type_id: The ID of the Domain Type to search the subtypes of. Because it duplicates the corresponding domainTypeId path parameter and prevents some client code generators from working as expected, this will be removed in the next quarterly release. (required)
        :param bool include_parent: Whether parent Domain Type should be included in the search result.
        :return: DomainTypePagedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.find_sub_domain_types_with_http_info(domain_type_id,  **kwargs)  # noqa: E501
        else:
            (data) = self.find_sub_domain_types_with_http_info(domain_type_id,  **kwargs)  # noqa: E501
            return data

    def find_sub_domain_types_with_http_info(self, domain_type_id,  **kwargs):  # noqa: E501
        """Returns sub domain types matching the given search criteria.  # noqa: E501

        Returns sub domain types matching the given search criteria.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.find_sub_domain_types_with_http_info(domain_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str domain_type_id: the unique identifier of the domain type (required)
        :param str domain_type_id: The ID of the Domain Type to search the subtypes of. Because it duplicates the corresponding domainTypeId path parameter and prevents some client code generators from working as expected, this will be removed in the next quarterly release. (required)
        :param bool include_parent: Whether parent Domain Type should be included in the search result.
        :return: DomainTypePagedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []
        if 'domain_type_id' in params:
            query_params.append(('domainTypeId', params['domain_type_id']))  # noqa: E501
        if 'include_parent' in params:
            query_params.append(('includeParent', params['include_parent']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes/{domainTypeId}/subTypes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DomainTypePagedResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_domain_type(self, domain_type_id, **kwargs):  # noqa: E501
        """Returns domain type identified by given UUID.  # noqa: E501

        Returns domain type identified by given UUID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_domain_type(domain_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str domain_type_id: the unique identifier of the domain type (required)
        :return: DomainTypeImpl
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_domain_type_with_http_info(domain_type_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_domain_type_with_http_info(domain_type_id, **kwargs)  # noqa: E501
            return data

    def get_domain_type_with_http_info(self, domain_type_id, **kwargs):  # noqa: E501
        """Returns domain type identified by given UUID.  # noqa: E501

        Returns domain type identified by given UUID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_domain_type_with_http_info(domain_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str domain_type_id: the unique identifier of the domain type (required)
        :return: DomainTypeImpl
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes/{domainTypeId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DomainTypeImpl',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def remove_domain_type(self, domain_type_id, **kwargs):  # noqa: E501
        """Removes domain type identified by given UUID.  # noqa: E501

        Removes domain type identified by given UUID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_domain_type(domain_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str domain_type_id: the unique identifier of the domain type (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.remove_domain_type_with_http_info(domain_type_id, **kwargs)  # noqa: E501
        else:
            (data) = self.remove_domain_type_with_http_info(domain_type_id, **kwargs)  # noqa: E501
            return data

    def remove_domain_type_with_http_info(self, domain_type_id, **kwargs):  # noqa: E501
        """Removes domain type identified by given UUID.  # noqa: E501

        Removes domain type identified by given UUID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_domain_type_with_http_info(domain_type_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str domain_type_id: the unique identifier of the domain type (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes/{domainTypeId}', '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 remove_domain_types(self, **kwargs):  # noqa: E501
        """Removes multiple domain types.  # noqa: E501

        Removes multiple domain types identified by the UUIDs passed as parameter.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_domain_types(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[str] body:
        :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.remove_domain_types_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.remove_domain_types_with_http_info(**kwargs)  # noqa: E501
            return data

    def remove_domain_types_with_http_info(self, **kwargs):  # noqa: E501
        """Removes multiple domain types.  # noqa: E501

        Removes multiple domain types identified by the UUIDs passed as parameter.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_domain_types_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[str] body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/domainTypes/bulk', '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)
