# coding: utf-8

"""
    Factern API

    No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)  # noqa: E501

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


class FactsApi(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_member(self, **kwargs):  # noqa: E501
        """Create Member  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_member(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateMemberRequest body:
        :return: CreateMemberResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.add_member_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.add_member_with_http_info(**kwargs)  # noqa: E501
            return data

    def add_member_with_http_info(self, **kwargs):  # noqa: E501
        """Create Member  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.add_member_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateMemberRequest body:
        :return: CreateMemberResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_member" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def bid(self, **kwargs):  # noqa: E501
        """Create Bid  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.bid(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateBidRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.bid_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.bid_with_http_info(**kwargs)  # noqa: E501
            return data

    def bid_with_http_info(self, **kwargs):  # noqa: E501
        """Create Bid  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.bid_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateBidRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createbid', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='StandardNodeResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_alias(self, **kwargs):  # noqa: E501
        """Create Alias  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_alias(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateAliasRequest body:
        :return: CreateAliasResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_alias_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_alias_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_alias_with_http_info(self, **kwargs):  # noqa: E501
        """Create Alias  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_alias_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateAliasRequest body:
        :return: CreateAliasResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_alias" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createalias', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateAliasResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_application(self, **kwargs):  # noqa: E501
        """Create Application  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_application(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateApplicationRequest body:
        :return: CreateApplicationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_application_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_application_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_application_with_http_info(self, **kwargs):  # noqa: E501
        """Create Application  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_application_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateApplicationRequest body:
        :return: CreateApplicationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_application" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createapplication', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateApplicationResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_domain(self, **kwargs):  # noqa: E501
        """Create Domain  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_domain(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateDomainRequest body:
        :return: CreateDomainResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_domain_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_domain_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_domain_with_http_info(self, **kwargs):  # noqa: E501
        """Create Domain  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_domain_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateDomainRequest body:
        :return: CreateDomainResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_domain" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createdomain', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateDomainResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_entity(self, **kwargs):  # noqa: E501
        """Create Entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_entity(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateEntityRequest body:
        :return: CreateEntityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_entity_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_entity_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_entity_with_http_info(self, **kwargs):  # noqa: E501
        """Create Entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_entity_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateEntityRequest body:
        :return: CreateEntityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_entity" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createentity', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateEntityResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_field(self, **kwargs):  # noqa: E501
        """Create Field  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_field(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateFieldRequest body:
        :return: CreateFieldResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_field_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_field_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_field_with_http_info(self, **kwargs):  # noqa: E501
        """Create Field  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_field_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateFieldRequest body:
        :return: CreateFieldResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_field" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createfield', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateFieldResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_filter(self, **kwargs):  # noqa: E501
        """Create Filter  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_filter(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateFilterRequest body:
        :return: CreateFilterResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_filter_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_filter_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_filter_with_http_info(self, **kwargs):  # noqa: E501
        """Create Filter  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_filter_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateFilterRequest body:
        :return: CreateFilterResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_filter" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createfilter', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateFilterResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_group(self, **kwargs):  # noqa: E501
        """Create Group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_group(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateGroupRequest body:
        :return: CreateGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_group_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_group_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_group_with_http_info(self, **kwargs):  # noqa: E501
        """Create Group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_group_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateGroupRequest body:
        :return: CreateGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_group" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/creategroup', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateGroupResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_information(self, **kwargs):  # noqa: E501
        """Create Information  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_information(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateInformationRequest body:
        :return: CreateInformationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_information_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_information_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_information_with_http_info(self, **kwargs):  # noqa: E501
        """Create Information  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_information_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateInformationRequest body:
        :return: CreateInformationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_information" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createinformation', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateInformationResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_interface(self, **kwargs):  # noqa: E501
        """Create Interface  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_interface(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateInterfaceRequest body:
        :return: CreateInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_interface_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_interface_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_interface_with_http_info(self, **kwargs):  # noqa: E501
        """Create Interface  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_interface_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateInterfaceRequest body:
        :return: CreateInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_interface" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createinterface', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateInterfaceResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_label_list(self, **kwargs):  # noqa: E501
        """Create Label List  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_label_list(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateLabelListRequest body:
        :return: CreateLabelListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_label_list_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_label_list_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_label_list_with_http_info(self, **kwargs):  # noqa: E501
        """Create Label List  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_label_list_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateLabelListRequest body:
        :return: CreateLabelListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_label_list" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createlabellist', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateLabelListResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_login(self, **kwargs):  # noqa: E501
        """Create Login  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_login(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateLoginRequest body:
        :return: CreateLoginResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_login_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_login_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_login_with_http_info(self, **kwargs):  # noqa: E501
        """Create Login  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_login_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateLoginRequest body:
        :return: CreateLoginResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_login" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createlogin', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateLoginResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_mirror(self, **kwargs):  # noqa: E501
        """Create Mirror  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_mirror(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateMirrorRequest body:
        :return: CreateMirrorResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_mirror_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_mirror_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_mirror_with_http_info(self, **kwargs):  # noqa: E501
        """Create Mirror  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_mirror_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateMirrorRequest body:
        :return: CreateMirrorResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_mirror" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createmirror', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateMirrorResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_price(self, **kwargs):  # noqa: E501
        """Create Price  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_price(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreatePriceRequest body:
        :return: CreatePriceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_price_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_price_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_price_with_http_info(self, **kwargs):  # noqa: E501
        """Create Price  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_price_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreatePriceRequest body:
        :return: CreatePriceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_price" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createprice', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreatePriceResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_scope(self, **kwargs):  # noqa: E501
        """Create Scope  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_scope(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateScopeRequest body:
        :return: CreateScopeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_scope_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_scope_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_scope_with_http_info(self, **kwargs):  # noqa: E501
        """Create Scope  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_scope_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateScopeRequest body:
        :return: CreateScopeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_scope" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createscope', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateScopeResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_statement(self, **kwargs):  # noqa: E501
        """Create Statement  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_statement(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param AddStatementRequest body:
        :return: AddStatementResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_statement_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_statement_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_statement_with_http_info(self, **kwargs):  # noqa: E501
        """Create Statement  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_statement_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param AddStatementRequest body:
        :return: AddStatementResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_statement" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createstatement', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AddStatementResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_template(self, **kwargs):  # noqa: E501
        """Create Template  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_template(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateTemplateRequest body:
        :return: CreateTemplateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.create_template_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_template_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_template_with_http_info(self, **kwargs):  # noqa: E501
        """Create Template  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.create_template_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateTemplateRequest body:
        :return: CreateTemplateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_template" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/createtemplate', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateTemplateResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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(self, **kwargs):  # noqa: E501
        """Deleting  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param DeleteRequest body:
        :return: ReadResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_with_http_info(self, **kwargs):  # noqa: E501
        """Deleting  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param DeleteRequest body:
        :return: ReadResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/delete', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ReadResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_node(self, **kwargs):  # noqa: E501
        """Delete Node  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_node(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param NodeIdRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.delete_node_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.delete_node_with_http_info(**kwargs)  # noqa: E501
            return data

    def delete_node_with_http_info(self, **kwargs):  # noqa: E501
        """Delete Node  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.delete_node_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param NodeIdRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_node" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def describe(self, **kwargs):  # noqa: E501
        """Describe  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.describe(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param DescribeRequest body:
        :return: DescribeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.describe_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.describe_with_http_info(**kwargs)  # noqa: E501
            return data

    def describe_with_http_info(self, **kwargs):  # noqa: E501
        """Describe  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.describe_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param DescribeRequest body:
        :return: DescribeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def history(self, **kwargs):  # noqa: E501
        """History  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.history(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param NodeIdRequest body:
        :return: NodeListing
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.history_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.history_with_http_info(**kwargs)  # noqa: E501
            return data

    def history_with_http_info(self, **kwargs):  # noqa: E501
        """History  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.history_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param NodeIdRequest body:
        :return: NodeListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def label(self, **kwargs):  # noqa: E501
        """Label a Node  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.label(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param AddLabelRequest body:
        :return: AddLabelResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.label_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.label_with_http_info(**kwargs)  # noqa: E501
            return data

    def label_with_http_info(self, **kwargs):  # noqa: E501
        """Label a Node  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.label_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param AddLabelRequest body:
        :return: AddLabelResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def obliterate(self, **kwargs):  # noqa: E501
        """Obliterating Information Nodes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.obliterate(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param NodeIdRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.obliterate_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.obliterate_with_http_info(**kwargs)  # noqa: E501
            return data

    def obliterate_with_http_info(self, **kwargs):  # noqa: E501
        """Obliterating Information Nodes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.obliterate_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param NodeIdRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def permission(self, **kwargs):  # noqa: E501
        """Create Permission  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.permission(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreatePermissionRequest body:
        :return: CreatePermissionResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.permission_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.permission_with_http_info(**kwargs)  # noqa: E501
            return data

    def permission_with_http_info(self, **kwargs):  # noqa: E501
        """Create Permission  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.permission_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreatePermissionRequest body:
        :return: CreatePermissionResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def read(self, **kwargs):  # noqa: E501
        """Reading  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.read(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param ReadRequest body:
        :return: ReadResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.read_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.read_with_http_info(**kwargs)  # noqa: E501
            return data

    def read_with_http_info(self, **kwargs):  # noqa: E501
        """Reading  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.read_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param ReadRequest body:
        :return: ReadResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def read_information(self, **kwargs):  # noqa: E501
        """Read Information  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.read_information(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param ReadInformationRequest body:
        :return: ReadInformationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.read_information_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.read_information_with_http_info(**kwargs)  # noqa: E501
            return data

    def read_information_with_http_info(self, **kwargs):  # noqa: E501
        """Read Information  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.read_information_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param ReadInformationRequest body:
        :return: ReadInformationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def replace_information(self, **kwargs):  # noqa: E501
        """Replace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_information(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param ReplaceFieldRequest body:
        :return: Information
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.replace_information_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.replace_information_with_http_info(**kwargs)  # noqa: E501
            return data

    def replace_information_with_http_info(self, **kwargs):  # noqa: E501
        """Replace  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.replace_information_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param ReplaceFieldRequest body:
        :return: Information
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def request_permission(self, **kwargs):  # noqa: E501
        """Request Permission  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.request_permission(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param NodeIdRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.request_permission_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.request_permission_with_http_info(**kwargs)  # noqa: E501
            return data

    def request_permission_with_http_info(self, **kwargs):  # noqa: E501
        """Request Permission  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.request_permission_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param NodeIdRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def reset_login(self, **kwargs):  # noqa: E501
        """Changing Login Password  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.reset_login(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param ResetLoginCredentialsRequest body:
        :return: ResetLoginResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.reset_login_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.reset_login_with_http_info(**kwargs)  # noqa: E501
            return data

    def reset_login_with_http_info(self, **kwargs):  # noqa: E501
        """Changing Login Password  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.reset_login_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param ResetLoginCredentialsRequest body:
        :return: ResetLoginResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def search_alias(self, **kwargs):  # noqa: E501
        """Search For Alias  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.search_alias(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param SearchAliasRequest body:
        :return: SearchAliasResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.search_alias_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.search_alias_with_http_info(**kwargs)  # noqa: E501
            return data

    def search_alias_with_http_info(self, **kwargs):  # noqa: E501
        """Search For Alias  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.search_alias_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param SearchAliasRequest body:
        :return: SearchAliasResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def search_entity(self, **kwargs):  # noqa: E501
        """Search For Entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.search_entity(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param SearchEntityRequest body:
        :return: EntityListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.search_entity_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.search_entity_with_http_info(**kwargs)  # noqa: E501
            return data

    def search_entity_with_http_info(self, **kwargs):  # noqa: E501
        """Search For Entity  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.search_entity_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param SearchEntityRequest body:
        :return: EntityListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def settle_account(self, **kwargs):  # noqa: E501
        """Settle Account  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.settle_account(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param SettleAccountRequest body:
        :return: SettleAccountResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.settle_account_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.settle_account_with_http_info(**kwargs)  # noqa: E501
            return data

    def settle_account_with_http_info(self, **kwargs):  # noqa: E501
        """Settle Account  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.settle_account_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param SettleAccountRequest body:
        :return: SettleAccountResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/settleaccount', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SettleAccountResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_application(self, **kwargs):  # noqa: E501
        """Resetting Application Secret  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_application(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param UpdateApplicationRequest body:
        :return: UpdateApplicationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.update_application_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.update_application_with_http_info(**kwargs)  # noqa: E501
            return data

    def update_application_with_http_info(self, **kwargs):  # noqa: E501
        """Resetting Application Secret  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_application_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param UpdateApplicationRequest body:
        :return: UpdateApplicationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_application" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

        return self.api_client.call_api(
            '/updateapplication', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UpdateApplicationResponse',  # noqa: E501
            auth_settings=auth_settings,
            async=params.get('async'),
            _return_http_data_only=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_status(self, **kwargs):  # noqa: E501
        """Enabling/Disabling Nodes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_status(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param UpdateStatusRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.update_status_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.update_status_with_http_info(**kwargs)  # noqa: E501
            return data

    def update_status_with_http_info(self, **kwargs):  # noqa: E501
        """Enabling/Disabling Nodes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.update_status_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param UpdateStatusRequest body:
        :return: StandardNodeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        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_status" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def watch(self, **kwargs):  # noqa: E501
        """Create Watch Trigger  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.watch(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateWatchRequest body:
        :return: CreateWatchResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.watch_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.watch_with_http_info(**kwargs)  # noqa: E501
            return data

    def watch_with_http_info(self, **kwargs):  # noqa: E501
        """Create Watch Trigger  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.watch_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param CreateWatchRequest body:
        :return: CreateWatchResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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

    def write(self, **kwargs):  # noqa: E501
        """Writing by Template  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.write(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param WriteRequest body:
        :return: WriteResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async'):
            return self.write_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.write_with_http_info(**kwargs)  # noqa: E501
            return data

    def write_with_http_info(self, **kwargs):  # noqa: E501
        """Writing by Template  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async=True
        >>> thread = api.write_with_http_info(async=True)
        >>> result = thread.get()

        :param async bool
        :param str login:
        :param str representing:
        :param WriteRequest body:
        :return: WriteResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['login', 'representing', 'body']  # noqa: E501
        all_params.append('async')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

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

        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

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

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