# 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 DevelopmentMemberAPIV30Api(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_notificationv3(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_notificationv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param NotificationPermissionV30 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_notificationv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.add_permission_notificationv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def add_permission_notificationv3_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_notificationv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param NotificationPermissionV30 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_notificationv3" % 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_notificationv3`")  # 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(
            '/v3.0/{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_addressv3(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_addressv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param AddressV30 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_addressv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_addressv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_addressv3_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_addressv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param AddressV30 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_addressv3" % 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_addressv3`")  # 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(
            '/v3.0/{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_distinctionv3(self, orcid, **kwargs):  # noqa: E501
        """Create an Distinction  # 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_distinctionv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param DistinctionV30 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_distinctionv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_distinctionv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_distinctionv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create an Distinction  # 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_distinctionv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param DistinctionV30 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_distinctionv3" % 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_distinctionv3`")  # 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(
            '/v3.0/{orcid}/distinction', '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_educationv3(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_educationv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param EducationV30 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_educationv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_educationv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_educationv3_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_educationv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param EducationV30 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_educationv3" % 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_educationv3`")  # 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(
            '/v3.0/{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_employmentv3(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_employmentv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param EmploymentV30 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_employmentv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_employmentv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_employmentv3_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_employmentv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param EmploymentV30 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_employmentv3" % 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_employmentv3`")  # 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(
            '/v3.0/{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_identifierv3(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_identifierv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param PersonExternalIdentifierV30 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_identifierv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_external_identifierv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_external_identifierv3_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_identifierv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param PersonExternalIdentifierV30 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_identifierv3" % 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_identifierv3`")  # 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(
            '/v3.0/{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_fundingv3(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_fundingv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param FundingV30 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_fundingv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_fundingv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_fundingv3_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_fundingv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param FundingV30 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_fundingv3" % 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_fundingv3`")  # 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(
            '/v3.0/{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_recordv3(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_recordv3(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_recordv3_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.create_group_id_recordv3_with_http_info(**kwargs)  # noqa: E501
            return data

    def create_group_id_recordv3_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_recordv3_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_recordv3" % 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(
            '/v3.0/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_invited_positionv3(self, orcid, **kwargs):  # noqa: E501
        """Create an InvitedPosition  # 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_invited_positionv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param InvitedPositionV30 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_invited_positionv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_invited_positionv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_invited_positionv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create an InvitedPosition  # 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_invited_positionv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param InvitedPositionV30 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_invited_positionv3" % 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_invited_positionv3`")  # 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(
            '/v3.0/{orcid}/invited-position', '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_keywordv3(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_keywordv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param KeywordV30 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_keywordv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_keywordv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_keywordv3_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_keywordv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param KeywordV30 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_keywordv3" % 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_keywordv3`")  # 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(
            '/v3.0/{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_membershipv3(self, orcid, **kwargs):  # noqa: E501
        """Create an Membership  # 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_membershipv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param MembershipV30 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_membershipv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_membershipv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_membershipv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create an Membership  # 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_membershipv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param MembershipV30 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_membershipv3" % 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_membershipv3`")  # 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(
            '/v3.0/{orcid}/membership', '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_other_namev3(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_namev3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param OtherNameV30 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_namev3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_other_namev3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_other_namev3_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_namev3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param OtherNameV30 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_namev3" % 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_namev3`")  # 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(
            '/v3.0/{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_reviewv3(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_reviewv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param PeerReviewV30 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_reviewv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_peer_reviewv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_peer_reviewv3_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_reviewv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param PeerReviewV30 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_reviewv3" % 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_reviewv3`")  # 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(
            '/v3.0/{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_qualificationv3(self, orcid, **kwargs):  # noqa: E501
        """Create an Qualification  # 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_qualificationv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param QualificationV30 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_qualificationv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_qualificationv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_qualificationv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create an Qualification  # 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_qualificationv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param QualificationV30 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_qualificationv3" % 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_qualificationv3`")  # 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(
            '/v3.0/{orcid}/qualification', '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_research_resourcev3(self, orcid, **kwargs):  # noqa: E501
        """Create a Research Resource  # 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_research_resourcev3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param ResearchResourceV30 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_research_resourcev3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_research_resourcev3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_research_resourcev3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create a Research Resource  # 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_research_resourcev3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param ResearchResourceV30 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_research_resourcev3" % 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_research_resourcev3`")  # 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(
            '/v3.0/{orcid}/research-resource', '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_urlv3(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_urlv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param ResearcherUrlV30 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_urlv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_researcher_urlv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_researcher_urlv3_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_urlv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param ResearcherUrlV30 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_urlv3" % 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_urlv3`")  # 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(
            '/v3.0/{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_servicev3(self, orcid, **kwargs):  # noqa: E501
        """Create an Service  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param ServiceV30 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_servicev3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_servicev3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_servicev3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create an Service  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param ServiceV30 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_servicev3" % 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_servicev3`")  # 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(
            '/v3.0/{orcid}/service', '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_worksv3(self, orcid, **kwargs):  # noqa: E501
        """Create a listo 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_worksv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param WorkBulkV30 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_worksv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_worksv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_worksv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Create a listo 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_worksv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param WorkBulkV30 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_worksv3" % 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_worksv3`")  # 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(
            '/v3.0/{orcid}/works', '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_workv3(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_workv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param WorkV30 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_workv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.create_workv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def create_workv3_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_workv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param WorkV30 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_workv3" % 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_workv3`")  # 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(
            '/v3.0/{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 delete_addressv3(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_addressv3(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_addressv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_addressv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_addressv3_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_addressv3_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_addressv3" % 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_addressv3`")  # 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_addressv3`")  # 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(
            '/v3.0/{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_distinctionv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Distinction  # 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_distinctionv3(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_distinctionv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_distinctionv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_distinctionv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Distinction  # 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_distinctionv3_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_distinctionv3" % 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_distinctionv3`")  # 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_distinctionv3`")  # 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(
            '/v3.0/{orcid}/distinction/{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_educationv3(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_educationv3(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_educationv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_educationv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_educationv3_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_educationv3_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_educationv3" % 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_educationv3`")  # 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_educationv3`")  # 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(
            '/v3.0/{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_employmentv3(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_employmentv3(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_employmentv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_employmentv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_employmentv3_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_employmentv3_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_employmentv3" % 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_employmentv3`")  # 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_employmentv3`")  # 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(
            '/v3.0/{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_identifierv3(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_identifierv3(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_identifierv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_external_identifierv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_external_identifierv3_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_identifierv3_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_identifierv3" % 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_identifierv3`")  # 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_identifierv3`")  # 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(
            '/v3.0/{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_fundingv3(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_fundingv3(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_fundingv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_fundingv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_fundingv3_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_fundingv3_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_fundingv3" % 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_fundingv3`")  # 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_fundingv3`")  # 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(
            '/v3.0/{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_recordv3(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_recordv3(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_recordv3_with_http_info(put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_group_id_recordv3_with_http_info(put_code, **kwargs)  # noqa: E501
            return data

    def delete_group_id_recordv3_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_recordv3_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_recordv3" % 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_recordv3`")  # 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(
            '/v3.0/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_invited_positionv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an InvitedPosition  # 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_invited_positionv3(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_invited_positionv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_invited_positionv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_invited_positionv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an InvitedPosition  # 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_invited_positionv3_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_invited_positionv3" % 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_invited_positionv3`")  # 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_invited_positionv3`")  # 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(
            '/v3.0/{orcid}/invited-position/{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_keywordv3(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_keywordv3(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_keywordv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_keywordv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_keywordv3_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_keywordv3_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_keywordv3" % 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_keywordv3`")  # 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_keywordv3`")  # 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(
            '/v3.0/{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_membershipv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Membership  # 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_membershipv3(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_membershipv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_membershipv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_membershipv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Membership  # 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_membershipv3_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_membershipv3" % 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_membershipv3`")  # 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_membershipv3`")  # 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(
            '/v3.0/{orcid}/membership/{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_namev3(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_namev3(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_namev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_other_namev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_other_namev3_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_namev3_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_namev3" % 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_namev3`")  # 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_namev3`")  # 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(
            '/v3.0/{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_reviewv3(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_reviewv3(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_reviewv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_peer_reviewv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_peer_reviewv3_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_reviewv3_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_reviewv3" % 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_reviewv3`")  # 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_reviewv3`")  # 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(
            '/v3.0/{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_qualificationv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Qualification  # 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_qualificationv3(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_qualificationv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_qualificationv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_qualificationv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Qualification  # 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_qualificationv3_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_qualificationv3" % 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_qualificationv3`")  # 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_qualificationv3`")  # 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(
            '/v3.0/{orcid}/qualification/{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_research_resourcev3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Research Resource  # 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_research_resourcev3(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_research_resourcev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_research_resourcev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_research_resourcev3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Research Resource  # 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_research_resourcev3_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_research_resourcev3" % 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_research_resourcev3`")  # 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_research_resourcev3`")  # 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(
            '/v3.0/{orcid}/research-resource/{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_urlv3(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_urlv3(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_urlv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_researcher_urlv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_researcher_urlv3_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_urlv3_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_urlv3" % 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_urlv3`")  # 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_urlv3`")  # 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(
            '/v3.0/{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_servicev3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Delete an Service  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_servicev3(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_servicev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_servicev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

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

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_servicev3_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_servicev3" % 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_servicev3`")  # 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_servicev3`")  # 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(
            '/v3.0/{orcid}/service/{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_workv3(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_workv3(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_workv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_workv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def delete_workv3_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_workv3_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_workv3" % 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_workv3`")  # 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_workv3`")  # 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(
            '/v3.0/{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_addressv3(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_addressv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param AddressV30 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_addressv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.edit_addressv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def edit_addressv3_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_addressv3_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 AddressV30 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_addressv3" % 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_addressv3`")  # 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_addressv3`")  # 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(
            '/v3.0/{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_identifierv3(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_identifierv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param PersonExternalIdentifierV30 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_identifierv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.edit_external_identifierv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def edit_external_identifierv3_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_identifierv3_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 PersonExternalIdentifierV30 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_identifierv3" % 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_identifierv3`")  # 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_identifierv3`")  # 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(
            '/v3.0/{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_keywordv3(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_keywordv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param KeywordV30 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_keywordv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.edit_keywordv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def edit_keywordv3_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_keywordv3_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 KeywordV30 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_keywordv3" % 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_keywordv3`")  # 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_keywordv3`")  # 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(
            '/v3.0/{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_namev3(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_namev3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param OtherNameV30 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_namev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.edit_other_namev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def edit_other_namev3_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_namev3_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 OtherNameV30 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_namev3" % 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_namev3`")  # 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_namev3`")  # 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(
            '/v3.0/{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_urlv3(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_urlv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param ResearcherUrlV30 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_urlv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.edit_researcher_urlv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def edit_researcher_urlv3_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_urlv3_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 ResearcherUrlV30 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_urlv3" % 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_urlv3`")  # 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_urlv3`")  # 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(
            '/v3.0/{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_notificationv3(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_notificationv3(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_notificationv3_with_http_info(orcid, id, **kwargs)  # noqa: E501
        else:
            (data) = self.flag_as_archived_permission_notificationv3_with_http_info(orcid, id, **kwargs)  # noqa: E501
            return data

    def flag_as_archived_permission_notificationv3_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_notificationv3_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_notificationv3" % 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_notificationv3`")  # 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_notificationv3`")  # 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(
            '/v3.0/{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_queryv3(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_queryv3(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str q:
        :return: SearchV30
                 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_queryv3_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.search_by_queryv3_with_http_info(**kwargs)  # noqa: E501
            return data

    def search_by_queryv3_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_queryv3_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str q:
        :return: SearchV30
                 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_queryv3" % 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(
            '/v3.0/search', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SearchV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_distinctionv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Distinction  # 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_distinctionv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param DistinctionV30 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_distinctionv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_distinctionv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_distinctionv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Distinction  # 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_distinctionv3_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 DistinctionV30 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_distinctionv3" % 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_distinctionv3`")  # 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_distinctionv3`")  # 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 `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(
            '/v3.0/{orcid}/distinction/{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_educationv3(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_educationv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param EducationV30 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_educationv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_educationv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_educationv3_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_educationv3_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 EducationV30 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_educationv3" % 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_educationv3`")  # 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_educationv3`")  # 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 `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(
            '/v3.0/{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_employmentv3(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_employmentv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param EmploymentV30 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_employmentv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_employmentv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_employmentv3_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_employmentv3_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 EmploymentV30 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_employmentv3" % 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_employmentv3`")  # 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_employmentv3`")  # 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 `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(
            '/v3.0/{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_fundingv3(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_fundingv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param FundingV30 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_fundingv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_fundingv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_fundingv3_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_fundingv3_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 FundingV30 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_fundingv3" % 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_fundingv3`")  # 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_fundingv3`")  # 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(
            '/v3.0/{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_recordv3(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_recordv3(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_recordv3_with_http_info(put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_group_id_recordv3_with_http_info(put_code, **kwargs)  # noqa: E501
            return data

    def update_group_id_recordv3_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_recordv3_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_recordv3" % 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_recordv3`")  # 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(
            '/v3.0/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_invited_positionv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an InvitedPosition  # 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_invited_positionv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param InvitedPositionV30 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_invited_positionv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_invited_positionv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_invited_positionv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an InvitedPosition  # 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_invited_positionv3_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 InvitedPositionV30 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_invited_positionv3" % 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_invited_positionv3`")  # 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_invited_positionv3`")  # 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 `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(
            '/v3.0/{orcid}/invited-position/{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_membershipv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Membership  # 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_membershipv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param MembershipV30 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_membershipv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_membershipv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_membershipv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Membership  # 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_membershipv3_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 MembershipV30 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_membershipv3" % 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_membershipv3`")  # 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_membershipv3`")  # 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 `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(
            '/v3.0/{orcid}/membership/{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_reviewv3(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_reviewv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param PeerReviewV30 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_reviewv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_peer_reviewv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_peer_reviewv3_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_reviewv3_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 PeerReviewV30 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_reviewv3" % 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_reviewv3`")  # 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_reviewv3`")  # 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(
            '/v3.0/{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_qualificationv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Qualification  # 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_qualificationv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param QualificationV30 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_qualificationv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_qualificationv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_qualificationv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Qualification  # 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_qualificationv3_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 QualificationV30 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_qualificationv3" % 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_qualificationv3`")  # 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_qualificationv3`")  # 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 `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(
            '/v3.0/{orcid}/qualification/{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_research_resourcev3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update a Research Resource  # 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_research_resourcev3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param ResearchResourceV30 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_research_resourcev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_research_resourcev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_research_resourcev3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update a Research Resource  # 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_research_resourcev3_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 ResearchResourceV30 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_research_resourcev3" % 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_research_resourcev3`")  # 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_research_resourcev3`")  # 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(
            '/v3.0/{orcid}/research-resource/{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_servicev3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Update an Service  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param ServiceV30 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_servicev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_servicev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

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

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_servicev3_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 ServiceV30 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_servicev3" % 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_servicev3`")  # 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_servicev3`")  # 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 `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(
            '/v3.0/{orcid}/service/{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_workv3(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_workv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :param WorkV30 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_workv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.update_workv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def update_workv3_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_workv3_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 WorkV30 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_workv3" % 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_workv3`")  # 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_workv3`")  # 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(
            '/v3.0/{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_activitiesv3(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_activitiesv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_activitiesv3_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_activitiesv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: ActivitiesSummaryV30
                 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_activitiesv3" % 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_activitiesv3`")  # 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(
            '/v3.0/{orcid}/activities', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ActivitiesSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_addressesv3(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_addressesv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_addressesv3_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_addressesv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: AddressesV30
                 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_addressesv3" % 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_addressesv3`")  # 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(
            '/v3.0/{orcid}/address', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AddressesV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_addressv3(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_addressv3(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.view_addressv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_addressv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_addressv3_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_addressv3_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 view_addressv3" % 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_addressv3`")  # 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_addressv3`")  # 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(
            '/v3.0/{orcid}/address/{putCode}', '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_biographyv3(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_biographyv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_biographyv3_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_biographyv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: BiographyV30
                 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_biographyv3" % 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_biographyv3`")  # 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(
            '/v3.0/{orcid}/biography', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='BiographyV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_clientv3(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_clientv3(client_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str client_id: (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_clientv3_with_http_info(client_id, **kwargs)  # noqa: E501
        else:
            (data) = self.view_clientv3_with_http_info(client_id, **kwargs)  # noqa: E501
            return data

    def view_clientv3_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_clientv3_with_http_info(client_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str client_id: (required)
        :return: None
                 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_clientv3" % 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_clientv3`")  # 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
        # Authentication setting
        auth_settings = ['orcid_two_legs']  # noqa: E501

        return self.api_client.call_api(
            '/v3.0/client/{client_id}', '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_distinction_summaryv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Distinction 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_distinction_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_distinction_summaryv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Distinction 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_distinction_summaryv3_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: DistinctionSummaryV30
                 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_distinction_summaryv3" % 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_distinction_summaryv3`")  # 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_distinction_summaryv3`")  # 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(
            '/v3.0/{orcid}/distinction/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DistinctionSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_distinctionsv3(self, orcid, **kwargs):  # noqa: E501
        """Fetch all distinctions  # 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_distinctionsv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_distinctionsv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all distinctions  # 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_distinctionsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: DistinctionsSummaryV30
                 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_distinctionsv3" % 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_distinctionsv3`")  # 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(
            '/v3.0/{orcid}/distinctions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DistinctionsSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_distinctionv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Distinction  # 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_distinctionv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_distinctionv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Distinction  # 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_distinctionv3_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: DistinctionV30
                 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_distinctionv3" % 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_distinctionv3`")  # 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_distinctionv3`")  # 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(
            '/v3.0/{orcid}/distinction/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DistinctionV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_summaryv3(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_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: EducationSummaryV30
                 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_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_education_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_education_summaryv3_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_summaryv3_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: EducationSummaryV30
                 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_summaryv3" % 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_summaryv3`")  # 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_summaryv3`")  # 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(
            '/v3.0/{orcid}/education/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EducationSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_educationsv3(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_educationsv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_educationsv3_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_educationsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: EducationsSummaryV30
                 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_educationsv3" % 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_educationsv3`")  # 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(
            '/v3.0/{orcid}/educations', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EducationsSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_educationv3(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_educationv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_educationv3_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_educationv3_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: EducationV30
                 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_educationv3" % 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_educationv3`")  # 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_educationv3`")  # 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(
            '/v3.0/{orcid}/education/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EducationV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_emailsv3(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_emailsv3(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_emailsv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.view_emailsv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def view_emailsv3_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_emailsv3_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_emailsv3" % 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_emailsv3`")  # 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(
            '/v3.0/{orcid}/email', '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_employment_summaryv3(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_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: EmploymentSummaryV30
                 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_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_employment_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_employment_summaryv3_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_summaryv3_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: EmploymentSummaryV30
                 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_summaryv3" % 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_summaryv3`")  # 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_summaryv3`")  # 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(
            '/v3.0/{orcid}/employment/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmploymentSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_employmentsv3(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_employmentsv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_employmentsv3_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_employmentsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: EmploymentsSummaryV30
                 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_employmentsv3" % 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_employmentsv3`")  # 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(
            '/v3.0/{orcid}/employments', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmploymentsSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_employmentv3(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_employmentv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_employmentv3_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_employmentv3_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: EmploymentV30
                 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_employmentv3" % 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_employmentv3`")  # 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_employmentv3`")  # 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(
            '/v3.0/{orcid}/employment/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmploymentV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_identifiersv3(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_identifiersv3(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_external_identifiersv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.view_external_identifiersv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def view_external_identifiersv3_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_identifiersv3_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_external_identifiersv3" % 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_identifiersv3`")  # 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(
            '/v3.0/{orcid}/external-identifiers', '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_external_identifierv3(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_identifierv3(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.view_external_identifierv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_external_identifierv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_external_identifierv3_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_identifierv3_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 view_external_identifierv3" % 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_identifierv3`")  # 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_identifierv3`")  # 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(
            '/v3.0/{orcid}/external-identifiers/{putCode}', '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_funding_summaryv3(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_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: FundingSummaryV30
                 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_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_funding_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_funding_summaryv3_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_summaryv3_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: FundingSummaryV30
                 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_summaryv3" % 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_summaryv3`")  # 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_summaryv3`")  # 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(
            '/v3.0/{orcid}/funding/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FundingSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_fundingsv3(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_fundingsv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_fundingsv3_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_fundingsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: FundingsV30
                 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_fundingsv3" % 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_fundingsv3`")  # 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(
            '/v3.0/{orcid}/fundings', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FundingsV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_fundingv3(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_fundingv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_fundingv3_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_fundingv3_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: FundingV30
                 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_fundingv3" % 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_fundingv3`")  # 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_fundingv3`")  # 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(
            '/v3.0/{orcid}/funding/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FundingV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_recordsv3(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_recordsv3(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_recordsv3_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.view_group_id_recordsv3_with_http_info(**kwargs)  # noqa: E501
            return data

    def view_group_id_recordsv3_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_recordsv3_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_recordsv3" % 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(
            '/v3.0/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_group_id_recordv3(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_recordv3(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_recordv3_with_http_info(put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_group_id_recordv3_with_http_info(put_code, **kwargs)  # noqa: E501
            return data

    def view_group_id_recordv3_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_recordv3_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_recordv3" % 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_recordv3`")  # 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(
            '/v3.0/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_invited_position_summaryv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an InvitedPosition 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_invited_position_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_invited_position_summaryv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an InvitedPosition 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_invited_position_summaryv3_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: InvitedPositionSummaryV30
                 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_invited_position_summaryv3" % 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_invited_position_summaryv3`")  # 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_invited_position_summaryv3`")  # 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(
            '/v3.0/{orcid}/invited-position/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InvitedPositionSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_invited_positionsv3(self, orcid, **kwargs):  # noqa: E501
        """Fetch all invitedPositions  # 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_invited_positionsv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_invited_positionsv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all invitedPositions  # 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_invited_positionsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: InvitedPositionsV30
                 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_invited_positionsv3" % 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_invited_positionsv3`")  # 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(
            '/v3.0/{orcid}/invited-positions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InvitedPositionsV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_invited_positionv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an InvitedPosition  # 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_invited_positionv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_invited_positionv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an InvitedPosition  # 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_invited_positionv3_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: InvitedPositionV30
                 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_invited_positionv3" % 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_invited_positionv3`")  # 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_invited_positionv3`")  # 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(
            '/v3.0/{orcid}/invited-position/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InvitedPositionV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_keywordsv3(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_keywordsv3(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_keywordsv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.view_keywordsv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def view_keywordsv3_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_keywordsv3_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_keywordsv3" % 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_keywordsv3`")  # 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(
            '/v3.0/{orcid}/keywords', '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_keywordv3(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_keywordv3(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.view_keywordv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_keywordv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_keywordv3_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_keywordv3_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 view_keywordv3" % 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_keywordv3`")  # 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_keywordv3`")  # 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(
            '/v3.0/{orcid}/keywords/{putCode}', '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_membership_summaryv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Membership 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_membership_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_membership_summaryv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Membership 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_membership_summaryv3_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: MembershipSummaryV30
                 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_membership_summaryv3" % 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_membership_summaryv3`")  # 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_membership_summaryv3`")  # 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(
            '/v3.0/{orcid}/membership/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MembershipSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_membershipsv3(self, orcid, **kwargs):  # noqa: E501
        """Fetch all memberships  # 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_membershipsv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_membershipsv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all memberships  # 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_membershipsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: MembershipsV30
                 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_membershipsv3" % 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_membershipsv3`")  # 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(
            '/v3.0/{orcid}/memberships', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MembershipsV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_membershipv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Membership  # 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_membershipv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_membershipv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Membership  # 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_membershipv3_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: MembershipV30
                 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_membershipv3" % 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_membershipv3`")  # 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_membershipv3`")  # 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(
            '/v3.0/{orcid}/membership/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MembershipV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_namesv3(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_namesv3(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_other_namesv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.view_other_namesv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def view_other_namesv3_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_namesv3_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_other_namesv3" % 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_namesv3`")  # 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(
            '/v3.0/{orcid}/other-names', '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_other_namev3(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_namev3(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.view_other_namev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_other_namev3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_other_namev3_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_namev3_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 view_other_namev3" % 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_namev3`")  # 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_namev3`")  # 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(
            '/v3.0/{orcid}/other-names/{putCode}', '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_peer_review_summaryv3(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_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: PeerReviewSummaryV30
                 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_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_peer_review_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_peer_review_summaryv3_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_summaryv3_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: PeerReviewSummaryV30
                 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_summaryv3" % 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_summaryv3`")  # 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_summaryv3`")  # 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(
            '/v3.0/{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='PeerReviewSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_reviewsv3(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_reviewsv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: PeerReviewsV30
                 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_reviewsv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.view_peer_reviewsv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def view_peer_reviewsv3_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_reviewsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: PeerReviewsV30
                 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_reviewsv3" % 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_reviewsv3`")  # 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(
            '/v3.0/{orcid}/peer-reviews', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PeerReviewsV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_reviewv3(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_reviewv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: PeerReviewV30
                 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_reviewv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_peer_reviewv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_peer_reviewv3_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_reviewv3_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: PeerReviewV30
                 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_reviewv3" % 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_reviewv3`")  # 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_reviewv3`")  # 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(
            '/v3.0/{orcid}/peer-review/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PeerReviewV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_notificationv3(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_notificationv3(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_notificationv3_with_http_info(orcid, id, **kwargs)  # noqa: E501
        else:
            (data) = self.view_permission_notificationv3_with_http_info(orcid, id, **kwargs)  # noqa: E501
            return data

    def view_permission_notificationv3_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_notificationv3_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_notificationv3" % 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_notificationv3`")  # 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_notificationv3`")  # 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(
            '/v3.0/{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_personal_detailsv3(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_detailsv3(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: PersonalDetailsV30
                 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_detailsv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.view_personal_detailsv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def view_personal_detailsv3_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_detailsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: PersonalDetailsV30
                 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_detailsv3" % 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_detailsv3`")  # 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(
            '/v3.0/{orcid}/personal-details', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PersonalDetailsV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_personv3(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_personv3(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_personv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.view_personv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def view_personv3_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_personv3_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_personv3" % 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_personv3`")  # 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(
            '/v3.0/{orcid}/person', '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_qualification_summaryv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Qualification 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_qualification_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_qualification_summaryv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Qualification 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_qualification_summaryv3_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: QualificationSummaryV30
                 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_qualification_summaryv3" % 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_qualification_summaryv3`")  # 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_qualification_summaryv3`")  # 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(
            '/v3.0/{orcid}/qualification/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='QualificationSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_qualificationsv3(self, orcid, **kwargs):  # noqa: E501
        """Fetch all qualifications  # 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_qualificationsv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_qualificationsv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all qualifications  # 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_qualificationsv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: QualificationsV30
                 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_qualificationsv3" % 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_qualificationsv3`")  # 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(
            '/v3.0/{orcid}/qualifications', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='QualificationsV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_qualificationv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Qualification  # 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_qualificationv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_qualificationv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Qualification  # 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_qualificationv3_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: QualificationV30
                 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_qualificationv3" % 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_qualificationv3`")  # 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_qualificationv3`")  # 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(
            '/v3.0/{orcid}/qualification/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='QualificationV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_recordv3(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_recordv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_recordv3_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_recordv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: RecordV30
                 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_recordv3" % 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_recordv3`")  # 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(
            '/v3.0/{orcid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RecordV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_research_resource_summaryv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Research Resource 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_research_resource_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_research_resource_summaryv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Research Resource 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_research_resource_summaryv3_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: ResearchResourceSummaryV30
                 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_research_resource_summaryv3" % 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_research_resource_summaryv3`")  # 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_research_resource_summaryv3`")  # 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(
            '/v3.0/{orcid}/research-resource/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResearchResourceSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_research_resourcesv3(self, orcid, **kwargs):  # noqa: E501
        """Fetch all Research Resources  # 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_research_resourcesv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_research_resourcesv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all Research Resources  # 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_research_resourcesv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: ResearchResourcesV30
                 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_research_resourcesv3" % 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_research_resourcesv3`")  # 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(
            '/v3.0/{orcid}/research-resources', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResearchResourcesV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_research_resourcev3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Research Resource  # 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_research_resourcev3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_research_resourcev3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch a Research Resource  # 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_research_resourcev3_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: ResearchResourceV30
                 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_research_resourcev3" % 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_research_resourcev3`")  # 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_research_resourcev3`")  # 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(
            '/v3.0/{orcid}/research-resource/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResearchResourceV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_urlsv3(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_urlsv3(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_researcher_urlsv3_with_http_info(orcid, **kwargs)  # noqa: E501
        else:
            (data) = self.view_researcher_urlsv3_with_http_info(orcid, **kwargs)  # noqa: E501
            return data

    def view_researcher_urlsv3_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_urlsv3_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_researcher_urlsv3" % 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_urlsv3`")  # 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(
            '/v3.0/{orcid}/researcher-urls', '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_researcher_urlv3(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_urlv3(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.view_researcher_urlv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_researcher_urlv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_researcher_urlv3_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_urlv3_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 view_researcher_urlv3" % 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_urlv3`")  # 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_urlv3`")  # 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(
            '/v3.0/{orcid}/researcher-urls/{putCode}', '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_service_summaryv3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Service 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_service_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_service_summaryv3_with_http_info(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Service 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_service_summaryv3_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: ServiceSummaryV30
                 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_service_summaryv3" % 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_service_summaryv3`")  # 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_service_summaryv3`")  # 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(
            '/v3.0/{orcid}/service/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ServiceSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_servicesv3(self, orcid, **kwargs):  # noqa: E501
        """Fetch all services  # noqa: E501

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

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

    def view_servicesv3_with_http_info(self, orcid, **kwargs):  # noqa: E501
        """Fetch all services  # noqa: E501

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

        :param async_req bool
        :param str orcid: (required)
        :return: ServicesV30
                 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_servicesv3" % 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_servicesv3`")  # 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(
            '/v3.0/{orcid}/services', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ServicesV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_servicev3(self, orcid, put_code, **kwargs):  # noqa: E501
        """Fetch an Service  # noqa: E501

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

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

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

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.view_servicev3_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: ServiceV30
                 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_servicev3" % 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_servicev3`")  # 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_servicev3`")  # 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(
            '/v3.0/{orcid}/service/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ServiceV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_worksv3(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_worksv3(orcid, put_codes, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_codes: (required)
        :return: WorkBulkV30
                 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_worksv3_with_http_info(orcid, put_codes, **kwargs)  # noqa: E501
        else:
            (data) = self.view_specified_worksv3_with_http_info(orcid, put_codes, **kwargs)  # noqa: E501
            return data

    def view_specified_worksv3_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_worksv3_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: WorkBulkV30
                 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_worksv3" % 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_worksv3`")  # 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_worksv3`")  # 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(
            '/v3.0/{orcid}/works/{putCodes}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WorkBulkV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_status_json(self, **kwargs):  # noqa: E501
        """view_status_json  # 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_status_json(async_req=True)
        >>> result = thread.get()

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

    def view_status_json_with_http_info(self, **kwargs):  # noqa: E501
        """view_status_json  # 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_status_json_with_http_info(async_req=True)
        >>> result = thread.get()

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

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        return self.api_client.call_api(
            '/v3.0/apiStatus', '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_work_summaryv3(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_summaryv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :param str put_code: (required)
        :return: WorkSummaryV30
                 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_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
        else:
            (data) = self.view_work_summaryv3_with_http_info(orcid, put_code, **kwargs)  # noqa: E501
            return data

    def view_work_summaryv3_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_summaryv3_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: WorkSummaryV30
                 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_summaryv3" % 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_summaryv3`")  # 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_summaryv3`")  # 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(
            '/v3.0/{orcid}/work/summary/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WorkSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_worksv3(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_worksv3(orcid, async_req=True)
        >>> result = thread.get()

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

    def view_worksv3_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_worksv3_with_http_info(orcid, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str orcid: (required)
        :return: WorksSummaryV30
                 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_worksv3" % 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_worksv3`")  # 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(
            '/v3.0/{orcid}/works', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WorksSummaryV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=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_workv3(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_workv3(orcid, put_code, async_req=True)
        >>> result = thread.get()

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

    def view_workv3_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_workv3_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: WorkV30
                 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_workv3" % 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_workv3`")  # 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_workv3`")  # 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(
            '/v3.0/{orcid}/work/{putCode}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WorkV30',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)
