# coding: utf-8

"""
    ORCID Member

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

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


class MemberAPIV21Api(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_permission_notification_v21(self, orcid, **kwargs):  # noqa: E501
        """Add a notification  # noqa: E501

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

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

    def add_permission_notification_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Add a notification  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param NotificationPermissionV20 body:
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/notification-permission', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_address_v21(self, orcid, **kwargs):  # noqa: E501
        """Add an address  # noqa: E501

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

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

    def create_address_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Add an address  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param AddressV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/address', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_education_v21(self, orcid, **kwargs):  # noqa: E501
        """Create an Education  # noqa: E501

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

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

    def create_education_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create an Education  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param EducationV20 body:
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/education', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_employment_v21(self, orcid, **kwargs):  # noqa: E501
        """Create an Employment  # noqa: E501

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

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

    def create_employment_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create an Employment  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param EmploymentV20 body:
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/employment', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_external_identifier_v21(self, orcid, **kwargs):  # noqa: E501
        """Add external identifier  # noqa: E501

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

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

    def create_external_identifier_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Add external identifier  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param PersonExternalIdentifierV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/external-identifiers', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_funding_v21(self, orcid, **kwargs):  # noqa: E501
        """Create a Funding  # noqa: E501

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

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

    def create_funding_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create a Funding  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param FundingV20 body:
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/funding', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

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

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

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

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

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

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/group-id-record', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_keyword_v21(self, orcid, **kwargs):  # noqa: E501
        """Add keyword  # noqa: E501

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

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

    def create_keyword_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Add keyword  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param KeywordV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/keywords', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_other_name_v21(self, orcid, **kwargs):  # noqa: E501
        """Add other name  # noqa: E501

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

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

    def create_other_name_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Add other name  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param OtherNameV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/other-names', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_peer_review_v21(self, orcid, **kwargs):  # noqa: E501
        """Create a Peer Review  # noqa: E501

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

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

    def create_peer_review_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create a Peer Review  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param PeerReviewV20 body:
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/peer-review', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_researcher_url_v21(self, orcid, **kwargs):  # noqa: E501
        """Add a new researcher url for an ORCID ID  # noqa: E501

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

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

    def create_researcher_url_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Add a new researcher url for an ORCID ID  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param ResearcherUrlV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/researcher-urls', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_work_v21(self, orcid, **kwargs):  # noqa: E501
        """Create a Work  # noqa: E501

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

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

    def create_work_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create a Work  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param WorkV20 body:
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/work', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_works_v21(self, orcid, **kwargs):  # noqa: E501
        """Create a list of Work  # noqa: E501

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

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

    def create_works_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create a list of Work  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param WorkBulkV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/works', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_address_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an address  # noqa: E501

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

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

    def delete_address_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an address  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/address/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_education_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Education  # noqa: E501

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

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

    def delete_education_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Education  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/education/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_employment_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Employment  # noqa: E501

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

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

    def delete_employment_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Employment  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/employment/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_external_identifier_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete external identifier  # noqa: E501

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

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

    def delete_external_identifier_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete external identifier  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/external-identifiers/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_funding_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete a Funding  # noqa: E501

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

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

    def delete_funding_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete a Funding  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/funding/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_group_id_record_v21(self, put_code, **kwargs):  # noqa: E501
        """Delete a Group  # noqa: E501

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

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

    def delete_group_id_record_v21_with_http_info(self, put_code, **kwargs):  # noqa: E501
        """Delete a Group  # noqa: E501

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

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

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_two_legs']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/group-id-record/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_keyword_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete keyword  # noqa: E501

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

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

    def delete_keyword_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete keyword  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/keywords/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_other_name_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete other name  # noqa: E501

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

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

    def delete_other_name_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete other name  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/other-names/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_peer_review_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete a Peer Review  # noqa: E501

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

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

    def delete_peer_review_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete a Peer Review  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/peer-review/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_researcher_url_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete one researcher url from an ORCID ID  # noqa: E501

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

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

    def delete_researcher_url_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete one researcher url from an ORCID ID  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/researcher-urls/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_work_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete a Work  # noqa: E501

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

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

    def delete_work_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete a Work  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

        return self.api_client.call_api(
            '/v2.1/{orcid}/work/{putCode}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def edit_address_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edit an address  # noqa: E501

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

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

    def edit_address_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edit an address  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param AddressV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/address/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def edit_external_identifier_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edit external identifier  # noqa: E501

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

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

    def edit_external_identifier_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edit external identifier  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param PersonExternalIdentifierV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/external-identifiers/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def edit_keyword_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edit keyword  # noqa: E501

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

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

    def edit_keyword_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edit keyword  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param KeywordV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/keywords/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def edit_other_name_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edit other name  # noqa: E501

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

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

    def edit_other_name_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edit other name  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param OtherNameV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/other-names/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def edit_researcher_url_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edits researcher url for an ORCID ID  # noqa: E501

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

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

    def edit_researcher_url_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Edits researcher url for an ORCID ID  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param ResearcherUrlV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/researcher-urls/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def flag_as_archived_permission_notification_v21(self, orcid, id, **kwargs):  # noqa: E501
        """Archive a notification  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param int id: (required)
        :return: Notification
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.flag_as_archived_permission_notification_v21_with_http_info(orcid, id, **kwargs)  # noqa: E501
        else:
            (data) = self.flag_as_archived_permission_notification_v21_with_http_info(orcid, id, **kwargs)  # noqa: E501
            return data

    def flag_as_archived_permission_notification_v21_with_http_info(self, orcid, id, **kwargs):  # noqa: E501
        """Archive a notification  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param int id: (required)
        :return: Notification
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/notification-permission/{id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Notification',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_by_query_v21(self, **kwargs):  # noqa: E501
        """Search records  # noqa: E501

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

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

    def search_by_query_v21_with_http_info(self, **kwargs):  # noqa: E501
        """Search records  # noqa: E501

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

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

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

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

        collection_formats = {}

        path_params = {}

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

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/search', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SearchV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_education_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Education  # noqa: E501

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

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

    def update_education_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Education  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param EducationV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/education/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_employment_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Employment  # noqa: E501

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

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

    def update_employment_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Employment  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param EmploymentV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/employment/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_funding_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update a Funding  # noqa: E501

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

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

    def update_funding_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update a Funding  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param FundingV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/funding/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_group_id_record_v21(self, put_code, **kwargs):  # noqa: E501
        """Update a Group  # noqa: E501

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

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

    def update_group_id_record_v21_with_http_info(self, put_code, **kwargs):  # noqa: E501
        """Update a Group  # noqa: E501

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

        :param async_req bool
        :param str put_code: (required)
        :param GroupIdRecord body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/group-id-record/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_peer_review_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update a Peer Review  # noqa: E501

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

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

    def update_peer_review_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update a Peer Review  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param PeerReviewV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/peer-review/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_work_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update a Work  # noqa: E501

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

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

    def update_work_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update a Work  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param WorkV20 body:
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/work/{putCode}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_activities_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all activities  # noqa: E501

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

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

    def view_activities_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all activities  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: ActivitiesSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_address_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an address  # noqa: E501

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

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

    def view_address_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an address  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: AddressV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_addresses_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all addresses of a profile  # noqa: E501

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

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

    def view_addresses_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all addresses of a profile  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: AddressesV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_biography_v21(self, orcid, **kwargs):  # noqa: E501
        """Get biography details  # noqa: E501

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

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

    def view_biography_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Get biography details  # noqa: E501

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

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

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['orcid_auth']  # noqa: E501

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

    def view_client_v21(self, client_id, **kwargs):  # noqa: E501
        """Fetch client details  # noqa: E501

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

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

    def view_client_v21_with_http_info(self, client_id, **kwargs):  # noqa: E501
        """Fetch client details  # noqa: E501

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

        :param async_req bool
        :param str client_id: (required)
        :return: ClientSummary
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_education_summary_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Education summary  # noqa: E501

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

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

    def view_education_summary_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Education summary  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: EducationSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/education/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EducationSummaryV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_education_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Education  # noqa: E501

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

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

    def view_education_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Education  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: EducationV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_educations_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all educations  # noqa: E501

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

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

    def view_educations_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all educations  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: EducationsSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_emails_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all emails for an ORCID ID  # noqa: E501

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

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

    def view_emails_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all emails for an ORCID ID  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: EmailsV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_employment_summary_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Employment Summary  # noqa: E501

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

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

    def view_employment_summary_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Employment Summary  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: EmploymentSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/employment/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmploymentSummaryV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_employment_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Employment  # noqa: E501

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

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

    def view_employment_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Employment  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: EmploymentV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_employments_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all employments  # noqa: E501

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

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

    def view_employments_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all employments  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: EmploymentsSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_external_identifier_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch external identifier  # noqa: E501

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

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

    def view_external_identifier_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch external identifier  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: PersonExternalIdentifierV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/external-identifiers/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PersonExternalIdentifierV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_external_identifiers_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch external identifiers  # noqa: E501

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

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

    def view_external_identifiers_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch external identifiers  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: PersonExternalIdentifiersV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/external-identifiers', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PersonExternalIdentifiersV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_funding_summary_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Funding Summary  # noqa: E501

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

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

    def view_funding_summary_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Funding Summary  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: FundingSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/funding/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FundingSummaryV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_funding_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Funding  # noqa: E501

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

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

    def view_funding_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Funding  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: FundingV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_fundings_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all fundings  # noqa: E501

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

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

    def view_fundings_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all fundings  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: FundingsV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_group_id_record_v21(self, put_code, **kwargs):  # noqa: E501
        """Fetch a Group  # noqa: E501

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

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

    def view_group_id_record_v21_with_http_info(self, put_code, **kwargs):  # noqa: E501
        """Fetch a Group  # noqa: E501

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

        :param async_req bool
        :param str put_code: (required)
        :return: GroupIdRecord
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/group-id-record/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GroupIdRecord',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_group_id_records_v21(self, **kwargs):  # noqa: E501
        """Fetch Groups  # noqa: E501

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

        :param async_req bool
        :param str page_size:
        :param str page:
        :param str name:
        :param str group_id:
        :return: GroupIdRecords
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.view_group_id_records_v21_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.view_group_id_records_v21_with_http_info(**kwargs)  # noqa: E501
            return data

    def view_group_id_records_v21_with_http_info(self, **kwargs):  # noqa: E501
        """Fetch Groups  # noqa: E501

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

        :param async_req bool
        :param str page_size:
        :param str page:
        :param str name:
        :param str group_id:
        :return: GroupIdRecords
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page', 'name', 'group_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'page_size' in params:
            query_params.append(('page-size', params['page_size']))  # noqa: E501
        if 'page' in params:
            query_params.append(('page', params['page']))  # noqa: E501
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501
        if 'group_id' in params:
            query_params.append(('group-id', params['group_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/group-id-record', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GroupIdRecords',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_keyword_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch keyword  # noqa: E501

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

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

    def view_keyword_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch keyword  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: KeywordV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_keywords_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch keywords  # noqa: E501

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

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

    def view_keywords_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch keywords  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: KeywordsV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_other_name_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch Other name  # noqa: E501

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

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

    def view_other_name_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch Other name  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: OtherNameV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/other-names/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='OtherNameV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_other_names_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch Other names  # noqa: E501

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

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

    def view_other_names_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch Other names  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: OtherNameV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/other-names', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='OtherNameV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_peer_review_summary_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Peer Review Summary  # noqa: E501

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

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

    def view_peer_review_summary_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Peer Review Summary  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: PeerReviewSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/peer-review/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PeerReviewSummaryV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_peer_review_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Peer Review  # noqa: E501

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

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

    def view_peer_review_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Peer Review  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: PeerReviewV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/peer-review/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PeerReviewV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_peer_reviews_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all peer reviews  # noqa: E501

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

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

    def view_peer_reviews_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all peer reviews  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: PeerReviewsV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/peer-reviews', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PeerReviewsV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_permission_notification_v21(self, orcid, id, **kwargs):  # noqa: E501
        """Fetch a notification by id  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param int id: (required)
        :return: Notification
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.view_permission_notification_v21_with_http_info(orcid, id, **kwargs)  # noqa: E501
        else:
            (data) = self.view_permission_notification_v21_with_http_info(orcid, id, **kwargs)  # noqa: E501
            return data

    def view_permission_notification_v21_with_http_info(self, orcid, id, **kwargs):  # noqa: E501
        """Fetch a notification by id  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param int id: (required)
        :return: Notification
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/notification-permission/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Notification',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_person_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch person details  # noqa: E501

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

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

    def view_person_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch person details  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: PersonV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_personal_details_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch personal details for an ORCID ID  # noqa: E501

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

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

    def view_personal_details_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch personal details for an ORCID ID  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: PersonalDetailsV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/personal-details', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PersonalDetailsV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_record_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch record details  # noqa: E501

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

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

    def view_record_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch record details  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: RecordV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_researcher_url_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch one researcher url for an ORCID ID  # noqa: E501

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

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

    def view_researcher_url_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch one researcher url for an ORCID ID  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: ResearcherUrlV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/researcher-urls/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResearcherUrlV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_researcher_urls_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all researcher urls for an ORCID ID  # noqa: E501

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

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

    def view_researcher_urls_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all researcher urls for an ORCID ID  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: ResearcherUrlsV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/researcher-urls', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResearcherUrlsV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_specified_works_v21(self, orcid, put_codes, **kwargs):  # noqa: E501
        """Fetch specified works  # noqa: E501

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

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

    def view_specified_works_v21_with_http_info(self, orcid, put_codes, **kwargs):  # noqa: E501
        """Fetch specified works  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_codes: (required)
        :return: WorkBulkV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_codes' in params:
            path_params['putCodes'] = params['put_codes']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_work_summary_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Work Summary  # noqa: E501

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

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

    def view_work_summary_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Work Summary  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: WorkSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

        return self.api_client.call_api(
            '/v2.1/{orcid}/work/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WorkSummaryV20',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def view_work_v21(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Work  # noqa: E501

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

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

    def view_work_v21_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Work  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: WorkV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}
        if 'orcid' in params:
            path_params['orcid'] = params['orcid']  # noqa: E501
        if 'put_code' in params:
            path_params['putCode'] = params['put_code']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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

    def view_works_v21(self, orcid, **kwargs):  # noqa: E501
        """Fetch all works  # noqa: E501

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

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

    def view_works_v21_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all works  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: WorksSummaryV20
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/vnd.orcid+xml; qs=5', 'application/orcid+xml; qs=3', 'application/xml', 'application/vnd.orcid+json; qs=4', 'application/orcid+json; qs=2', 'application/json'])  # noqa: E501

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

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