# coding: utf-8

"""
    Cherwell REST API

    Unofficial Python Cherwell REST API library.  # noqa: E501

    The version of the OpenAPI document: 9.3.2
    Contact: See AUTHORS.
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from pycherwell.api_client import ApiClient
from pycherwell.exceptions import (
    ApiTypeError,
    ApiValueError
)


class UsersApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def users_delete_user_batch_v1(self, user_batch_delete_request, **kwargs):  # noqa: E501
        """Delete a batch of users  # noqa: E501

        Operation to delete a batch of users. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_delete_user_batch_v1(user_batch_delete_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchDeleteRequest user_batch_delete_request: Request object listing record IDs for users to be deleted and an error flag. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserBatchDeleteResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_delete_user_batch_v1_with_http_info(user_batch_delete_request, **kwargs)  # noqa: E501

    def users_delete_user_batch_v1_with_http_info(self, user_batch_delete_request, **kwargs):  # noqa: E501
        """Delete a batch of users  # noqa: E501

        Operation to delete a batch of users. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_delete_user_batch_v1_with_http_info(user_batch_delete_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchDeleteRequest user_batch_delete_request: Request object listing record IDs for users to be deleted and an error flag. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserBatchDeleteResponse, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_delete_user_batch_v1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'user_batch_delete_request' is set
        if self.api_client.client_side_validation and ('user_batch_delete_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['user_batch_delete_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `user_batch_delete_request` when calling `users_delete_user_batch_v1`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_delete_user_batch_v2(self, user_batch_delete_request, **kwargs):  # noqa: E501
        """Delete a batch of users  # noqa: E501

        Operation to delete a batch of users. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_delete_user_batch_v2(user_batch_delete_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchDeleteRequest user_batch_delete_request: Request object listing record IDs for users to be deleted and an error flag. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserBatchDeleteV2Response
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_delete_user_batch_v2_with_http_info(user_batch_delete_request, **kwargs)  # noqa: E501

    def users_delete_user_batch_v2_with_http_info(self, user_batch_delete_request, **kwargs):  # noqa: E501
        """Delete a batch of users  # noqa: E501

        Operation to delete a batch of users. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_delete_user_batch_v2_with_http_info(user_batch_delete_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchDeleteRequest user_batch_delete_request: Request object listing record IDs for users to be deleted and an error flag. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserBatchDeleteV2Response, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_delete_user_batch_v2" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'user_batch_delete_request' is set
        if self.api_client.client_side_validation and ('user_batch_delete_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['user_batch_delete_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `user_batch_delete_request` when calling `users_delete_user_batch_v2`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_delete_user_v1(self, userrecordid, **kwargs):  # noqa: E501
        """Delete a user by record ID  # noqa: E501

        Operation to delete a user by record ID. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_delete_user_v1(userrecordid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str userrecordid: Specify the record ID of the user you want to delete (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserDeleteResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_delete_user_v1_with_http_info(userrecordid, **kwargs)  # noqa: E501

    def users_delete_user_v1_with_http_info(self, userrecordid, **kwargs):  # noqa: E501
        """Delete a user by record ID  # noqa: E501

        Operation to delete a user by record ID. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_delete_user_v1_with_http_info(userrecordid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str userrecordid: Specify the record ID of the user you want to delete (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserDeleteResponse, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_delete_user_v1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'userrecordid' is set
        if self.api_client.client_side_validation and ('userrecordid' not in local_var_params or  # noqa: E501
                                                        local_var_params['userrecordid'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `userrecordid` when calling `users_delete_user_v1`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'userrecordid' in local_var_params:
            path_params['userrecordid'] = local_var_params['userrecordid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/api/V1/deleteuser/userrecordid/{userrecordid}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UserDeleteResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def users_delete_user_v2(self, userrecordid, **kwargs):  # noqa: E501
        """Delete a user by record ID  # noqa: E501

        Operation to delete a user by record ID. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_delete_user_v2(userrecordid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str userrecordid: Specify the record ID of the user you want to delete (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserDeleteV2Response
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_delete_user_v2_with_http_info(userrecordid, **kwargs)  # noqa: E501

    def users_delete_user_v2_with_http_info(self, userrecordid, **kwargs):  # noqa: E501
        """Delete a user by record ID  # noqa: E501

        Operation to delete a user by record ID. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_delete_user_v2_with_http_info(userrecordid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str userrecordid: Specify the record ID of the user you want to delete (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserDeleteV2Response, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_delete_user_v2" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'userrecordid' is set
        if self.api_client.client_side_validation and ('userrecordid' not in local_var_params or  # noqa: E501
                                                        local_var_params['userrecordid'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `userrecordid` when calling `users_delete_user_v2`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'userrecordid' in local_var_params:
            path_params['userrecordid'] = local_var_params['userrecordid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/api/V2/deleteuser/userrecordid/{userrecordid}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UserDeleteV2Response',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def users_get_list_of_users(self, loginidfilter, **kwargs):  # noqa: E501
        """Get a list of all system users.  # noqa: E501

        Operation to get a list of all system users.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_list_of_users(loginidfilter, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str loginidfilter: Specify the login ID filter to apply to the users list. (required)
        :param bool stoponerror: Specify whether the operation is interrupted if retrieving any user causes an error.
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_get_list_of_users_with_http_info(loginidfilter, **kwargs)  # noqa: E501

    def users_get_list_of_users_with_http_info(self, loginidfilter, **kwargs):  # noqa: E501
        """Get a list of all system users.  # noqa: E501

        Operation to get a list of all system users.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_list_of_users_with_http_info(loginidfilter, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str loginidfilter: Specify the login ID filter to apply to the users list. (required)
        :param bool stoponerror: Specify whether the operation is interrupted if retrieving any user causes an error.
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserListResponse, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_get_list_of_users" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'loginidfilter' is set
        if self.api_client.client_side_validation and ('loginidfilter' not in local_var_params or  # noqa: E501
                                                        local_var_params['loginidfilter'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `loginidfilter` when calling `users_get_list_of_users`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'loginidfilter' in local_var_params and local_var_params['loginidfilter'] is not None:  # noqa: E501
            query_params.append(('loginidfilter', local_var_params['loginidfilter']))  # noqa: E501
        if 'stoponerror' in local_var_params and local_var_params['stoponerror'] is not None:  # noqa: E501
            query_params.append(('stoponerror', local_var_params['stoponerror']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_get_user_batch_v1(self, user_batch_read_request, **kwargs):  # noqa: E501
        """Get user information in a batch  # noqa: E501

        Operation to get user information in a batch. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_get_user_batch_v1(user_batch_read_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchReadRequest user_batch_read_request: Request object that lists user record IDs or public IDs of users and an error flag. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserBatchReadResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_get_user_batch_v1_with_http_info(user_batch_read_request, **kwargs)  # noqa: E501

    def users_get_user_batch_v1_with_http_info(self, user_batch_read_request, **kwargs):  # noqa: E501
        """Get user information in a batch  # noqa: E501

        Operation to get user information in a batch. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public 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.users_get_user_batch_v1_with_http_info(user_batch_read_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchReadRequest user_batch_read_request: Request object that lists user record IDs or public IDs of users and an error flag. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserBatchReadResponse, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_get_user_batch_v1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'user_batch_read_request' is set
        if self.api_client.client_side_validation and ('user_batch_read_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['user_batch_read_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `user_batch_read_request` when calling `users_get_user_batch_v1`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_get_user_by_login_id_v1(self, loginid, **kwargs):  # noqa: E501
        """Get a user by login ID  # noqa: E501

        Operation to get detailed user information by login ID. Use to get user record IDs and account settings, for example. This operation has been deprecated by a V2 operation of the same name, but with query string parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_login_id_v1(loginid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str loginid: Specify the user's login ID. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: User
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_get_user_by_login_id_v1_with_http_info(loginid, **kwargs)  # noqa: E501

    def users_get_user_by_login_id_v1_with_http_info(self, loginid, **kwargs):  # noqa: E501
        """Get a user by login ID  # noqa: E501

        Operation to get detailed user information by login ID. Use to get user record IDs and account settings, for example. This operation has been deprecated by a V2 operation of the same name, but with query string parameters.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_login_id_v1_with_http_info(loginid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str loginid: Specify the user's login ID. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(User, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_get_user_by_login_id_v1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'loginid' is set
        if self.api_client.client_side_validation and ('loginid' not in local_var_params or  # noqa: E501
                                                        local_var_params['loginid'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `loginid` when calling `users_get_user_by_login_id_v1`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'loginid' in local_var_params:
            path_params['loginid'] = local_var_params['loginid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/api/V1/getuserbyloginid/loginid/{loginid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='User',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def users_get_user_by_login_id_v2(self, loginid, loginidtype, **kwargs):  # noqa: E501
        """Get a user by login ID and login ID type  # noqa: E501

        Operation to get detailed user information by login ID. Use to get user record IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_login_id_v2(loginid, loginidtype, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str loginid: Specify the user's login ID. (required)
        :param str loginidtype: Specify the login ID type. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: User
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_get_user_by_login_id_v2_with_http_info(loginid, loginidtype, **kwargs)  # noqa: E501

    def users_get_user_by_login_id_v2_with_http_info(self, loginid, loginidtype, **kwargs):  # noqa: E501
        """Get a user by login ID and login ID type  # noqa: E501

        Operation to get detailed user information by login ID. Use to get user record IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_login_id_v2_with_http_info(loginid, loginidtype, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str loginid: Specify the user's login ID. (required)
        :param str loginidtype: Specify the login ID type. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(User, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_get_user_by_login_id_v2" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'loginid' is set
        if self.api_client.client_side_validation and ('loginid' not in local_var_params or  # noqa: E501
                                                        local_var_params['loginid'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `loginid` when calling `users_get_user_by_login_id_v2`")  # noqa: E501
        # verify the required parameter 'loginidtype' is set
        if self.api_client.client_side_validation and ('loginidtype' not in local_var_params or  # noqa: E501
                                                        local_var_params['loginidtype'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `loginidtype` when calling `users_get_user_by_login_id_v2`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'loginid' in local_var_params and local_var_params['loginid'] is not None:  # noqa: E501
            query_params.append(('loginid', local_var_params['loginid']))  # noqa: E501
        if 'loginidtype' in local_var_params and local_var_params['loginidtype'] is not None:  # noqa: E501
            query_params.append(('loginidtype', local_var_params['loginidtype']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_get_user_by_login_id_v3(self, loginid, loginidtype, **kwargs):  # noqa: E501
        """Get a user by login ID and login ID type  # noqa: E501

        Operation to get detailed user information by login ID. Use to get user record IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_login_id_v3(loginid, loginidtype, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str loginid: Specify the user's login ID. (required)
        :param str loginidtype: Specify the login ID type. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserV2
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_get_user_by_login_id_v3_with_http_info(loginid, loginidtype, **kwargs)  # noqa: E501

    def users_get_user_by_login_id_v3_with_http_info(self, loginid, loginidtype, **kwargs):  # noqa: E501
        """Get a user by login ID and login ID type  # noqa: E501

        Operation to get detailed user information by login ID. Use to get user record IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_login_id_v3_with_http_info(loginid, loginidtype, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str loginid: Specify the user's login ID. (required)
        :param str loginidtype: Specify the login ID type. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserV2, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_get_user_by_login_id_v3" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'loginid' is set
        if self.api_client.client_side_validation and ('loginid' not in local_var_params or  # noqa: E501
                                                        local_var_params['loginid'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `loginid` when calling `users_get_user_by_login_id_v3`")  # noqa: E501
        # verify the required parameter 'loginidtype' is set
        if self.api_client.client_side_validation and ('loginidtype' not in local_var_params or  # noqa: E501
                                                        local_var_params['loginidtype'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `loginidtype` when calling `users_get_user_by_login_id_v3`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'loginid' in local_var_params and local_var_params['loginid'] is not None:  # noqa: E501
            query_params.append(('loginid', local_var_params['loginid']))  # noqa: E501
        if 'loginidtype' in local_var_params and local_var_params['loginidtype'] is not None:  # noqa: E501
            query_params.append(('loginidtype', local_var_params['loginidtype']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_get_user_by_public_id_v1(self, publicid, **kwargs):  # noqa: E501
        """Get a user by public ID  # noqa: E501

        Operation to get detailed user information by public ID. Use to get user record IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_public_id_v1(publicid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str publicid: Specify the user's public ID. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserReadResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_get_user_by_public_id_v1_with_http_info(publicid, **kwargs)  # noqa: E501

    def users_get_user_by_public_id_v1_with_http_info(self, publicid, **kwargs):  # noqa: E501
        """Get a user by public ID  # noqa: E501

        Operation to get detailed user information by public ID. Use to get user record IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_public_id_v1_with_http_info(publicid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str publicid: Specify the user's public ID. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserReadResponse, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_get_user_by_public_id_v1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'publicid' is set
        if self.api_client.client_side_validation and ('publicid' not in local_var_params or  # noqa: E501
                                                        local_var_params['publicid'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `publicid` when calling `users_get_user_by_public_id_v1`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'publicid' in local_var_params:
            path_params['publicid'] = local_var_params['publicid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/api/V1/getuserbypublicid/publicid/{publicid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UserReadResponse',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def users_get_user_by_public_id_v2(self, publicid, **kwargs):  # noqa: E501
        """Get a user by public ID  # noqa: E501

        Operation to get detailed user information by public ID. Use to get user record IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_public_id_v2(publicid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str publicid: Specify the user's public ID. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserReadV2Response
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_get_user_by_public_id_v2_with_http_info(publicid, **kwargs)  # noqa: E501

    def users_get_user_by_public_id_v2_with_http_info(self, publicid, **kwargs):  # noqa: E501
        """Get a user by public ID  # noqa: E501

        Operation to get detailed user information by public ID. Use to get user record IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_public_id_v2_with_http_info(publicid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str publicid: Specify the user's public ID. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserReadV2Response, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_get_user_by_public_id_v2" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'publicid' is set
        if self.api_client.client_side_validation and ('publicid' not in local_var_params or  # noqa: E501
                                                        local_var_params['publicid'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `publicid` when calling `users_get_user_by_public_id_v2`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'publicid' in local_var_params:
            path_params['publicid'] = local_var_params['publicid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/api/V2/getuserbypublicid/publicid/{publicid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UserReadV2Response',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def users_get_user_by_rec_id(self, recid, **kwargs):  # noqa: E501
        """Get a user by record ID  # noqa: E501

        Operation to get detailed user information by record ID.  Use to get user public IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_rec_id(recid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str recid: Specify the user's record ID (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserV2
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_get_user_by_rec_id_with_http_info(recid, **kwargs)  # noqa: E501

    def users_get_user_by_rec_id_with_http_info(self, recid, **kwargs):  # noqa: E501
        """Get a user by record ID  # noqa: E501

        Operation to get detailed user information by record ID.  Use to get user public IDs and account settings, for example.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_get_user_by_rec_id_with_http_info(recid, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str recid: Specify the user's record ID (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserV2, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_get_user_by_rec_id" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'recid' is set
        if self.api_client.client_side_validation and ('recid' not in local_var_params or  # noqa: E501
                                                        local_var_params['recid'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `recid` when calling `users_get_user_by_rec_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'recid' in local_var_params:
            path_params['recid'] = local_var_params['recid']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = []  # noqa: E501

        return self.api_client.call_api(
            '/api/V1/getuserbyrecid/recid/{recid}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UserV2',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def users_save_user_batch_v1(self, user_batch_save_request, **kwargs):  # noqa: E501
        """Create or update users in a batch  # noqa: E501

        Operation to create or update users in a batch. To update, specify record ID. To create, leave record ID empty.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_save_user_batch_v1(user_batch_save_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchSaveRequest user_batch_save_request: Request object listing user record IDs and an error flag. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserBatchSaveResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_save_user_batch_v1_with_http_info(user_batch_save_request, **kwargs)  # noqa: E501

    def users_save_user_batch_v1_with_http_info(self, user_batch_save_request, **kwargs):  # noqa: E501
        """Create or update users in a batch  # noqa: E501

        Operation to create or update users in a batch. To update, specify record ID. To create, leave record ID empty.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_save_user_batch_v1_with_http_info(user_batch_save_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchSaveRequest user_batch_save_request: Request object listing user record IDs and an error flag. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserBatchSaveResponse, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_save_user_batch_v1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'user_batch_save_request' is set
        if self.api_client.client_side_validation and ('user_batch_save_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['user_batch_save_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `user_batch_save_request` when calling `users_save_user_batch_v1`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_save_user_batch_v2(self, user_batch_save_v2_request, **kwargs):  # noqa: E501
        """Create or update users in a batch  # noqa: E501

        Operation to create or update users in a batch. To update, specify record ID. To create, leave record ID empty.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_save_user_batch_v2(user_batch_save_v2_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchSaveV2Request user_batch_save_v2_request: Request object listing user record IDs and an error flag. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserBatchSaveV2Response
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_save_user_batch_v2_with_http_info(user_batch_save_v2_request, **kwargs)  # noqa: E501

    def users_save_user_batch_v2_with_http_info(self, user_batch_save_v2_request, **kwargs):  # noqa: E501
        """Create or update users in a batch  # noqa: E501

        Operation to create or update users in a batch. To update, specify record ID. To create, leave record ID empty.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_save_user_batch_v2_with_http_info(user_batch_save_v2_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserBatchSaveV2Request user_batch_save_v2_request: Request object listing user record IDs and an error flag. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserBatchSaveV2Response, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_save_user_batch_v2" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'user_batch_save_v2_request' is set
        if self.api_client.client_side_validation and ('user_batch_save_v2_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['user_batch_save_v2_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `user_batch_save_v2_request` when calling `users_save_user_batch_v2`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_save_user_v1(self, user_save_request, **kwargs):  # noqa: E501
        """Create or update a user  # noqa: E501

        Operation to create or update a user.  The response is a collection because if you use a public ID, more than one user could be updated since public IDs may not be unique.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_save_user_v1(user_save_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserSaveRequest user_save_request: Request object to specify user parameters and fields with values to be created or updated. The loginId and either the Business Object record ID or Public ID are required. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserSaveResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_save_user_v1_with_http_info(user_save_request, **kwargs)  # noqa: E501

    def users_save_user_v1_with_http_info(self, user_save_request, **kwargs):  # noqa: E501
        """Create or update a user  # noqa: E501

        Operation to create or update a user.  The response is a collection because if you use a public ID, more than one user could be updated since public IDs may not be unique.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_save_user_v1_with_http_info(user_save_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserSaveRequest user_save_request: Request object to specify user parameters and fields with values to be created or updated. The loginId and either the Business Object record ID or Public ID are required. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserSaveResponse, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_save_user_v1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'user_save_request' is set
        if self.api_client.client_side_validation and ('user_save_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['user_save_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `user_save_request` when calling `users_save_user_v1`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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

    def users_save_user_v2(self, user_save_v2_request, **kwargs):  # noqa: E501
        """Create or update a user  # noqa: E501

        Operation to create or update a user.  The response is a collection because if you use a public ID, more than one user could be updated since public IDs may not be unique.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_save_user_v2(user_save_v2_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserSaveV2Request user_save_v2_request: Request object to specify user parameters and fields with values to be created or updated. The loginId and either the Business Object record ID or Public ID are required. (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: UserSaveV2Response
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.users_save_user_v2_with_http_info(user_save_v2_request, **kwargs)  # noqa: E501

    def users_save_user_v2_with_http_info(self, user_save_v2_request, **kwargs):  # noqa: E501
        """Create or update a user  # noqa: E501

        Operation to create or update a user.  The response is a collection because if you use a public ID, more than one user could be updated since public IDs may not be unique.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.users_save_user_v2_with_http_info(user_save_v2_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UserSaveV2Request user_save_v2_request: Request object to specify user parameters and fields with values to be created or updated. The loginId and either the Business Object record ID or Public ID are required. (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(UserSaveV2Response, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method users_save_user_v2" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'user_save_v2_request' is set
        if self.api_client.client_side_validation and ('user_save_v2_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['user_save_v2_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `user_save_v2_request` when calling `users_save_user_v2`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = []  # noqa: E501

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