docusign_esign.apis.users_api

   1# coding: utf-8
   2
   3"""
   4    DocuSign REST API
   5
   6    The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign.  # noqa: E501
   7
   8    OpenAPI spec version: v2.1
   9    Contact: devcenter@docusign.com
  10    Generated by: https://github.com/swagger-api/swagger-codegen.git
  11"""
  12
  13
  14from __future__ import absolute_import
  15
  16import sys
  17import os
  18import re
  19
  20# python 2 and python 3 compatibility library
  21from six import iteritems
  22
  23from ..client.configuration import Configuration
  24from ..client.api_client import ApiClient
  25
  26
  27class UsersApi(object):
  28    """
  29    NOTE: This class is auto generated by the swagger code generator program.
  30    Do not edit the class manually.
  31    Ref: https://github.com/swagger-api/swagger-codegen
  32    """
  33
  34    def __init__(self, api_client=None):
  35        config = Configuration()
  36        if api_client:
  37            self.api_client = api_client
  38        else:
  39            if not config.api_client:
  40                config.api_client = ApiClient()
  41            self.api_client = config.api_client
  42
  43    def create(self, account_id, **kwargs):
  44        """
  45        Adds news user to the specified account.
  46        Adds new users to your account. Set the `userSettings` property in the request to specify the actions the users can perform on the account.
  47        This method makes a synchronous HTTP request by default. To make an
  48        asynchronous HTTP request, please define a `callback` function
  49        to be invoked when receiving the response.
  50        >>> def callback_function(response):
  51        >>>     pprint(response)
  52        >>>
  53        >>> thread = api.create(account_id, callback=callback_function)
  54
  55        :param callback function: The callback function
  56            for asynchronous request. (optional)
  57        :param str account_id: The external account number (int) or account ID Guid. (required)
  58        :param NewUsersDefinition new_users_definition:
  59        :return: NewUsersSummary
  60                 If the method is called asynchronously,
  61                 returns the request thread.
  62        """
  63        kwargs['_return_http_data_only'] = True
  64        if kwargs.get('callback'):
  65            return self.create_with_http_info(account_id, **kwargs)
  66        else:
  67            (data) = self.create_with_http_info(account_id, **kwargs)
  68            return data
  69
  70    def create_with_http_info(self, account_id, **kwargs):
  71        """
  72        Adds news user to the specified account.
  73        Adds new users to your account. Set the `userSettings` property in the request to specify the actions the users can perform on the account.
  74        This method makes a synchronous HTTP request by default. To make an
  75        asynchronous HTTP request, please define a `callback` function
  76        to be invoked when receiving the response.
  77        >>> def callback_function(response):
  78        >>>     pprint(response)
  79        >>>
  80        >>> thread = api.create_with_http_info(account_id, callback=callback_function)
  81
  82        :param callback function: The callback function
  83            for asynchronous request. (optional)
  84        :param str account_id: The external account number (int) or account ID Guid. (required)
  85        :param NewUsersDefinition new_users_definition:
  86        :return: NewUsersSummary
  87                 If the method is called asynchronously,
  88                 returns the request thread.
  89        """
  90
  91        all_params = ['account_id', 'new_users_definition']
  92        all_params.append('callback')
  93        all_params.append('_return_http_data_only')
  94        all_params.append('_preload_content')
  95        all_params.append('_request_timeout')
  96
  97        params = locals()
  98        for key, val in iteritems(params['kwargs']):
  99            if key not in all_params:
 100                raise TypeError(
 101                    "Got an unexpected keyword argument '%s'"
 102                    " to method create" % key
 103                )
 104            params[key] = val
 105        del params['kwargs']
 106        # verify the required parameter 'account_id' is set
 107        if ('account_id' not in params) or (params['account_id'] is None):
 108            raise ValueError("Missing the required parameter `account_id` when calling `create`")
 109
 110
 111        collection_formats = {}
 112
 113        resource_path = '/v2.1/accounts/{accountId}/users'.replace('{format}', 'json')
 114        path_params = {}
 115        if 'account_id' in params:
 116            path_params['accountId'] = params['account_id']
 117
 118        query_params = {}
 119
 120        header_params = {}
 121
 122        form_params = []
 123        local_var_files = {}
 124
 125        body_params = None
 126        if 'new_users_definition' in params:
 127            body_params = params['new_users_definition']
 128        # HTTP header `Accept`
 129        header_params['Accept'] = self.api_client.\
 130            select_header_accept(['application/json'])
 131
 132        # Authentication setting
 133        auth_settings = []
 134
 135        return self.api_client.call_api(resource_path, 'POST',
 136                                        path_params,
 137                                        query_params,
 138                                        header_params,
 139                                        body=body_params,
 140                                        post_params=form_params,
 141                                        files=local_var_files,
 142                                        response_type='NewUsersSummary',
 143                                        auth_settings=auth_settings,
 144                                        callback=params.get('callback'),
 145                                        _return_http_data_only=params.get('_return_http_data_only'),
 146                                        _preload_content=params.get('_preload_content', True),
 147                                        _request_timeout=params.get('_request_timeout'),
 148                                        collection_formats=collection_formats)
 149
 150    def create_signatures(self, account_id, user_id, **kwargs):
 151        """
 152        Adds user Signature and initials images to a Signature.
 153        Adds a user signature image and/or user initials image to the specified user.   The userId property specified in the endpoint must match the authenticated user's userId and the user must be a member of the account.  The rules and processes associated with this are:  * If Content-Type is set to application/json, then the default behavior for creating a default signature image, based on the name and a DocuSign font, is used. * If Content-Type is set to multipart/form-data, then the request must contain a first part with the user signature information, followed by parts that contain the images.  For each Image part, the Content-Disposition header has a \"filename\" value that is used to map to the `signatureName` and/or `signatureInitials` properties in the JSON to the image.   For example:  `Content-Disposition: file; filename=\"Ron Test20121127083900\"`  If no matching image (by filename value) is found, then the image is not set. One, both, or neither of the signature and initials images can be set with this call.  The Content-Transfer-Encoding: base64 header, set in the header for the part containing the image, can be set to indicate that the images are formatted as base64 instead of as binary.  If successful, 200-OK is returned, and a JSON structure containing the signature information is provided, note that the signatureId can change with each API POST, PUT, or DELETE since the changes to the signature structure cause the current signature to be closed, and a new signature record to be created.
 154        This method makes a synchronous HTTP request by default. To make an
 155        asynchronous HTTP request, please define a `callback` function
 156        to be invoked when receiving the response.
 157        >>> def callback_function(response):
 158        >>>     pprint(response)
 159        >>>
 160        >>> thread = api.create_signatures(account_id, user_id, callback=callback_function)
 161
 162        :param callback function: The callback function
 163            for asynchronous request. (optional)
 164        :param str account_id: The external account number (int) or account ID Guid. (required)
 165        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 166        :param UserSignaturesInformation user_signatures_information:
 167        :return: UserSignaturesInformation
 168                 If the method is called asynchronously,
 169                 returns the request thread.
 170        """
 171        kwargs['_return_http_data_only'] = True
 172        if kwargs.get('callback'):
 173            return self.create_signatures_with_http_info(account_id, user_id, **kwargs)
 174        else:
 175            (data) = self.create_signatures_with_http_info(account_id, user_id, **kwargs)
 176            return data
 177
 178    def create_signatures_with_http_info(self, account_id, user_id, **kwargs):
 179        """
 180        Adds user Signature and initials images to a Signature.
 181        Adds a user signature image and/or user initials image to the specified user.   The userId property specified in the endpoint must match the authenticated user's userId and the user must be a member of the account.  The rules and processes associated with this are:  * If Content-Type is set to application/json, then the default behavior for creating a default signature image, based on the name and a DocuSign font, is used. * If Content-Type is set to multipart/form-data, then the request must contain a first part with the user signature information, followed by parts that contain the images.  For each Image part, the Content-Disposition header has a \"filename\" value that is used to map to the `signatureName` and/or `signatureInitials` properties in the JSON to the image.   For example:  `Content-Disposition: file; filename=\"Ron Test20121127083900\"`  If no matching image (by filename value) is found, then the image is not set. One, both, or neither of the signature and initials images can be set with this call.  The Content-Transfer-Encoding: base64 header, set in the header for the part containing the image, can be set to indicate that the images are formatted as base64 instead of as binary.  If successful, 200-OK is returned, and a JSON structure containing the signature information is provided, note that the signatureId can change with each API POST, PUT, or DELETE since the changes to the signature structure cause the current signature to be closed, and a new signature record to be created.
 182        This method makes a synchronous HTTP request by default. To make an
 183        asynchronous HTTP request, please define a `callback` function
 184        to be invoked when receiving the response.
 185        >>> def callback_function(response):
 186        >>>     pprint(response)
 187        >>>
 188        >>> thread = api.create_signatures_with_http_info(account_id, user_id, callback=callback_function)
 189
 190        :param callback function: The callback function
 191            for asynchronous request. (optional)
 192        :param str account_id: The external account number (int) or account ID Guid. (required)
 193        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 194        :param UserSignaturesInformation user_signatures_information:
 195        :return: UserSignaturesInformation
 196                 If the method is called asynchronously,
 197                 returns the request thread.
 198        """
 199
 200        all_params = ['account_id', 'user_id', 'user_signatures_information']
 201        all_params.append('callback')
 202        all_params.append('_return_http_data_only')
 203        all_params.append('_preload_content')
 204        all_params.append('_request_timeout')
 205
 206        params = locals()
 207        for key, val in iteritems(params['kwargs']):
 208            if key not in all_params:
 209                raise TypeError(
 210                    "Got an unexpected keyword argument '%s'"
 211                    " to method create_signatures" % key
 212                )
 213            params[key] = val
 214        del params['kwargs']
 215        # verify the required parameter 'account_id' is set
 216        if ('account_id' not in params) or (params['account_id'] is None):
 217            raise ValueError("Missing the required parameter `account_id` when calling `create_signatures`")
 218        # verify the required parameter 'user_id' is set
 219        if ('user_id' not in params) or (params['user_id'] is None):
 220            raise ValueError("Missing the required parameter `user_id` when calling `create_signatures`")
 221
 222
 223        collection_formats = {}
 224
 225        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures'.replace('{format}', 'json')
 226        path_params = {}
 227        if 'account_id' in params:
 228            path_params['accountId'] = params['account_id']
 229        if 'user_id' in params:
 230            path_params['userId'] = params['user_id']
 231
 232        query_params = {}
 233
 234        header_params = {}
 235
 236        form_params = []
 237        local_var_files = {}
 238
 239        body_params = None
 240        if 'user_signatures_information' in params:
 241            body_params = params['user_signatures_information']
 242        # HTTP header `Accept`
 243        header_params['Accept'] = self.api_client.\
 244            select_header_accept(['application/json'])
 245
 246        # Authentication setting
 247        auth_settings = []
 248
 249        return self.api_client.call_api(resource_path, 'POST',
 250                                        path_params,
 251                                        query_params,
 252                                        header_params,
 253                                        body=body_params,
 254                                        post_params=form_params,
 255                                        files=local_var_files,
 256                                        response_type='UserSignaturesInformation',
 257                                        auth_settings=auth_settings,
 258                                        callback=params.get('callback'),
 259                                        _return_http_data_only=params.get('_return_http_data_only'),
 260                                        _preload_content=params.get('_preload_content', True),
 261                                        _request_timeout=params.get('_request_timeout'),
 262                                        collection_formats=collection_formats)
 263
 264    def delete(self, account_id, **kwargs):
 265        """
 266        Removes users account privileges.
 267        This closes one or more user records in the account. Users are never deleted from an account, but closing a user prevents them from using account functions.  The response returns whether the API execution was successful (200 - OK) or  if it failed. The response contains a user structure similar to the request and includes the user changes. If an error occurred during the DELETE operation for any of the users, the response for that user contains an `errorDetails` node with `errorCode` and `message` properties.
 268        This method makes a synchronous HTTP request by default. To make an
 269        asynchronous HTTP request, please define a `callback` function
 270        to be invoked when receiving the response.
 271        >>> def callback_function(response):
 272        >>>     pprint(response)
 273        >>>
 274        >>> thread = api.delete(account_id, callback=callback_function)
 275
 276        :param callback function: The callback function
 277            for asynchronous request. (optional)
 278        :param str account_id: The external account number (int) or account ID Guid. (required)
 279        :param str delete:
 280        :param UserInfoList user_info_list:
 281        :return: UsersResponse
 282                 If the method is called asynchronously,
 283                 returns the request thread.
 284        """
 285        kwargs['_return_http_data_only'] = True
 286        if kwargs.get('callback'):
 287            return self.delete_with_http_info(account_id, **kwargs)
 288        else:
 289            (data) = self.delete_with_http_info(account_id, **kwargs)
 290            return data
 291
 292    def delete_with_http_info(self, account_id, **kwargs):
 293        """
 294        Removes users account privileges.
 295        This closes one or more user records in the account. Users are never deleted from an account, but closing a user prevents them from using account functions.  The response returns whether the API execution was successful (200 - OK) or  if it failed. The response contains a user structure similar to the request and includes the user changes. If an error occurred during the DELETE operation for any of the users, the response for that user contains an `errorDetails` node with `errorCode` and `message` properties.
 296        This method makes a synchronous HTTP request by default. To make an
 297        asynchronous HTTP request, please define a `callback` function
 298        to be invoked when receiving the response.
 299        >>> def callback_function(response):
 300        >>>     pprint(response)
 301        >>>
 302        >>> thread = api.delete_with_http_info(account_id, callback=callback_function)
 303
 304        :param callback function: The callback function
 305            for asynchronous request. (optional)
 306        :param str account_id: The external account number (int) or account ID Guid. (required)
 307        :param str delete:
 308        :param UserInfoList user_info_list:
 309        :return: UsersResponse
 310                 If the method is called asynchronously,
 311                 returns the request thread.
 312        """
 313
 314        all_params = ['account_id', 'delete', 'user_info_list']
 315        all_params.append('callback')
 316        all_params.append('_return_http_data_only')
 317        all_params.append('_preload_content')
 318        all_params.append('_request_timeout')
 319
 320        params = locals()
 321        for key, val in iteritems(params['kwargs']):
 322            if key not in all_params:
 323                raise TypeError(
 324                    "Got an unexpected keyword argument '%s'"
 325                    " to method delete" % key
 326                )
 327            params[key] = val
 328        del params['kwargs']
 329        # verify the required parameter 'account_id' is set
 330        if ('account_id' not in params) or (params['account_id'] is None):
 331            raise ValueError("Missing the required parameter `account_id` when calling `delete`")
 332
 333
 334        collection_formats = {}
 335
 336        resource_path = '/v2.1/accounts/{accountId}/users'.replace('{format}', 'json')
 337        path_params = {}
 338        if 'account_id' in params:
 339            path_params['accountId'] = params['account_id']
 340
 341        query_params = {}
 342        if 'delete' in params:
 343            query_params['delete'] = params['delete']
 344
 345        header_params = {}
 346
 347        form_params = []
 348        local_var_files = {}
 349
 350        body_params = None
 351        if 'user_info_list' in params:
 352            body_params = params['user_info_list']
 353        # HTTP header `Accept`
 354        header_params['Accept'] = self.api_client.\
 355            select_header_accept(['application/json'])
 356
 357        # Authentication setting
 358        auth_settings = []
 359
 360        return self.api_client.call_api(resource_path, 'DELETE',
 361                                        path_params,
 362                                        query_params,
 363                                        header_params,
 364                                        body=body_params,
 365                                        post_params=form_params,
 366                                        files=local_var_files,
 367                                        response_type='UsersResponse',
 368                                        auth_settings=auth_settings,
 369                                        callback=params.get('callback'),
 370                                        _return_http_data_only=params.get('_return_http_data_only'),
 371                                        _preload_content=params.get('_preload_content', True),
 372                                        _request_timeout=params.get('_request_timeout'),
 373                                        collection_formats=collection_formats)
 374
 375    def delete_contact_with_id(self, account_id, contact_id, **kwargs):
 376        """
 377        Replaces a particular contact associated with an account for the DocuSign service.
 378        This method deletes a contact associated with an account.
 379        This method makes a synchronous HTTP request by default. To make an
 380        asynchronous HTTP request, please define a `callback` function
 381        to be invoked when receiving the response.
 382        >>> def callback_function(response):
 383        >>>     pprint(response)
 384        >>>
 385        >>> thread = api.delete_contact_with_id(account_id, contact_id, callback=callback_function)
 386
 387        :param callback function: The callback function
 388            for asynchronous request. (optional)
 389        :param str account_id: The external account number (int) or account ID Guid. (required)
 390        :param str contact_id: The unique identifier of a person in the contacts address book. (required)
 391        :return: ContactUpdateResponse
 392                 If the method is called asynchronously,
 393                 returns the request thread.
 394        """
 395        kwargs['_return_http_data_only'] = True
 396        if kwargs.get('callback'):
 397            return self.delete_contact_with_id_with_http_info(account_id, contact_id, **kwargs)
 398        else:
 399            (data) = self.delete_contact_with_id_with_http_info(account_id, contact_id, **kwargs)
 400            return data
 401
 402    def delete_contact_with_id_with_http_info(self, account_id, contact_id, **kwargs):
 403        """
 404        Replaces a particular contact associated with an account for the DocuSign service.
 405        This method deletes a contact associated with an account.
 406        This method makes a synchronous HTTP request by default. To make an
 407        asynchronous HTTP request, please define a `callback` function
 408        to be invoked when receiving the response.
 409        >>> def callback_function(response):
 410        >>>     pprint(response)
 411        >>>
 412        >>> thread = api.delete_contact_with_id_with_http_info(account_id, contact_id, callback=callback_function)
 413
 414        :param callback function: The callback function
 415            for asynchronous request. (optional)
 416        :param str account_id: The external account number (int) or account ID Guid. (required)
 417        :param str contact_id: The unique identifier of a person in the contacts address book. (required)
 418        :return: ContactUpdateResponse
 419                 If the method is called asynchronously,
 420                 returns the request thread.
 421        """
 422
 423        all_params = ['account_id', 'contact_id']
 424        all_params.append('callback')
 425        all_params.append('_return_http_data_only')
 426        all_params.append('_preload_content')
 427        all_params.append('_request_timeout')
 428
 429        params = locals()
 430        for key, val in iteritems(params['kwargs']):
 431            if key not in all_params:
 432                raise TypeError(
 433                    "Got an unexpected keyword argument '%s'"
 434                    " to method delete_contact_with_id" % key
 435                )
 436            params[key] = val
 437        del params['kwargs']
 438        # verify the required parameter 'account_id' is set
 439        if ('account_id' not in params) or (params['account_id'] is None):
 440            raise ValueError("Missing the required parameter `account_id` when calling `delete_contact_with_id`")
 441        # verify the required parameter 'contact_id' is set
 442        if ('contact_id' not in params) or (params['contact_id'] is None):
 443            raise ValueError("Missing the required parameter `contact_id` when calling `delete_contact_with_id`")
 444
 445
 446        collection_formats = {}
 447
 448        resource_path = '/v2.1/accounts/{accountId}/contacts/{contactId}'.replace('{format}', 'json')
 449        path_params = {}
 450        if 'account_id' in params:
 451            path_params['accountId'] = params['account_id']
 452        if 'contact_id' in params:
 453            path_params['contactId'] = params['contact_id']
 454
 455        query_params = {}
 456
 457        header_params = {}
 458
 459        form_params = []
 460        local_var_files = {}
 461
 462        body_params = None
 463        # HTTP header `Accept`
 464        header_params['Accept'] = self.api_client.\
 465            select_header_accept(['application/json'])
 466
 467        # Authentication setting
 468        auth_settings = []
 469
 470        return self.api_client.call_api(resource_path, 'DELETE',
 471                                        path_params,
 472                                        query_params,
 473                                        header_params,
 474                                        body=body_params,
 475                                        post_params=form_params,
 476                                        files=local_var_files,
 477                                        response_type='ContactUpdateResponse',
 478                                        auth_settings=auth_settings,
 479                                        callback=params.get('callback'),
 480                                        _return_http_data_only=params.get('_return_http_data_only'),
 481                                        _preload_content=params.get('_preload_content', True),
 482                                        _request_timeout=params.get('_request_timeout'),
 483                                        collection_formats=collection_formats)
 484
 485    def delete_contacts(self, account_id, **kwargs):
 486        """
 487        Delete contacts associated with an account for the DocuSign service.
 488        This method deletes multiple contacts associated with an account.
 489        This method makes a synchronous HTTP request by default. To make an
 490        asynchronous HTTP request, please define a `callback` function
 491        to be invoked when receiving the response.
 492        >>> def callback_function(response):
 493        >>>     pprint(response)
 494        >>>
 495        >>> thread = api.delete_contacts(account_id, callback=callback_function)
 496
 497        :param callback function: The callback function
 498            for asynchronous request. (optional)
 499        :param str account_id: The external account number (int) or account ID Guid. (required)
 500        :param ContactModRequest contact_mod_request:
 501        :return: ContactUpdateResponse
 502                 If the method is called asynchronously,
 503                 returns the request thread.
 504        """
 505        kwargs['_return_http_data_only'] = True
 506        if kwargs.get('callback'):
 507            return self.delete_contacts_with_http_info(account_id, **kwargs)
 508        else:
 509            (data) = self.delete_contacts_with_http_info(account_id, **kwargs)
 510            return data
 511
 512    def delete_contacts_with_http_info(self, account_id, **kwargs):
 513        """
 514        Delete contacts associated with an account for the DocuSign service.
 515        This method deletes multiple contacts associated with an account.
 516        This method makes a synchronous HTTP request by default. To make an
 517        asynchronous HTTP request, please define a `callback` function
 518        to be invoked when receiving the response.
 519        >>> def callback_function(response):
 520        >>>     pprint(response)
 521        >>>
 522        >>> thread = api.delete_contacts_with_http_info(account_id, callback=callback_function)
 523
 524        :param callback function: The callback function
 525            for asynchronous request. (optional)
 526        :param str account_id: The external account number (int) or account ID Guid. (required)
 527        :param ContactModRequest contact_mod_request:
 528        :return: ContactUpdateResponse
 529                 If the method is called asynchronously,
 530                 returns the request thread.
 531        """
 532
 533        all_params = ['account_id', 'contact_mod_request']
 534        all_params.append('callback')
 535        all_params.append('_return_http_data_only')
 536        all_params.append('_preload_content')
 537        all_params.append('_request_timeout')
 538
 539        params = locals()
 540        for key, val in iteritems(params['kwargs']):
 541            if key not in all_params:
 542                raise TypeError(
 543                    "Got an unexpected keyword argument '%s'"
 544                    " to method delete_contacts" % key
 545                )
 546            params[key] = val
 547        del params['kwargs']
 548        # verify the required parameter 'account_id' is set
 549        if ('account_id' not in params) or (params['account_id'] is None):
 550            raise ValueError("Missing the required parameter `account_id` when calling `delete_contacts`")
 551
 552
 553        collection_formats = {}
 554
 555        resource_path = '/v2.1/accounts/{accountId}/contacts'.replace('{format}', 'json')
 556        path_params = {}
 557        if 'account_id' in params:
 558            path_params['accountId'] = params['account_id']
 559
 560        query_params = {}
 561
 562        header_params = {}
 563
 564        form_params = []
 565        local_var_files = {}
 566
 567        body_params = None
 568        if 'contact_mod_request' in params:
 569            body_params = params['contact_mod_request']
 570        # HTTP header `Accept`
 571        header_params['Accept'] = self.api_client.\
 572            select_header_accept(['application/json'])
 573
 574        # Authentication setting
 575        auth_settings = []
 576
 577        return self.api_client.call_api(resource_path, 'DELETE',
 578                                        path_params,
 579                                        query_params,
 580                                        header_params,
 581                                        body=body_params,
 582                                        post_params=form_params,
 583                                        files=local_var_files,
 584                                        response_type='ContactUpdateResponse',
 585                                        auth_settings=auth_settings,
 586                                        callback=params.get('callback'),
 587                                        _return_http_data_only=params.get('_return_http_data_only'),
 588                                        _preload_content=params.get('_preload_content', True),
 589                                        _request_timeout=params.get('_request_timeout'),
 590                                        collection_formats=collection_formats)
 591
 592    def delete_custom_settings(self, account_id, user_id, **kwargs):
 593        """
 594        Deletes custom user settings for a specified user.
 595        Deletes the specified custom user settings for a single user.  ###Deleting Grouped Custom User Settings###  If the custom user settings you want to delete are grouped, you must include the following information in the header, after Content-Type, in the request:  `X-DocuSign-User-Settings-Key:group_name`  Where the `group_name` is your designated name for the group of customer user settings.  If the extra header information is not included, only the custom user settings that were added without a group are deleted.
 596        This method makes a synchronous HTTP request by default. To make an
 597        asynchronous HTTP request, please define a `callback` function
 598        to be invoked when receiving the response.
 599        >>> def callback_function(response):
 600        >>>     pprint(response)
 601        >>>
 602        >>> thread = api.delete_custom_settings(account_id, user_id, callback=callback_function)
 603
 604        :param callback function: The callback function
 605            for asynchronous request. (optional)
 606        :param str account_id: The external account number (int) or account ID Guid. (required)
 607        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 608        :param CustomSettingsInformation custom_settings_information:
 609        :return: CustomSettingsInformation
 610                 If the method is called asynchronously,
 611                 returns the request thread.
 612        """
 613        kwargs['_return_http_data_only'] = True
 614        if kwargs.get('callback'):
 615            return self.delete_custom_settings_with_http_info(account_id, user_id, **kwargs)
 616        else:
 617            (data) = self.delete_custom_settings_with_http_info(account_id, user_id, **kwargs)
 618            return data
 619
 620    def delete_custom_settings_with_http_info(self, account_id, user_id, **kwargs):
 621        """
 622        Deletes custom user settings for a specified user.
 623        Deletes the specified custom user settings for a single user.  ###Deleting Grouped Custom User Settings###  If the custom user settings you want to delete are grouped, you must include the following information in the header, after Content-Type, in the request:  `X-DocuSign-User-Settings-Key:group_name`  Where the `group_name` is your designated name for the group of customer user settings.  If the extra header information is not included, only the custom user settings that were added without a group are deleted.
 624        This method makes a synchronous HTTP request by default. To make an
 625        asynchronous HTTP request, please define a `callback` function
 626        to be invoked when receiving the response.
 627        >>> def callback_function(response):
 628        >>>     pprint(response)
 629        >>>
 630        >>> thread = api.delete_custom_settings_with_http_info(account_id, user_id, callback=callback_function)
 631
 632        :param callback function: The callback function
 633            for asynchronous request. (optional)
 634        :param str account_id: The external account number (int) or account ID Guid. (required)
 635        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 636        :param CustomSettingsInformation custom_settings_information:
 637        :return: CustomSettingsInformation
 638                 If the method is called asynchronously,
 639                 returns the request thread.
 640        """
 641
 642        all_params = ['account_id', 'user_id', 'custom_settings_information']
 643        all_params.append('callback')
 644        all_params.append('_return_http_data_only')
 645        all_params.append('_preload_content')
 646        all_params.append('_request_timeout')
 647
 648        params = locals()
 649        for key, val in iteritems(params['kwargs']):
 650            if key not in all_params:
 651                raise TypeError(
 652                    "Got an unexpected keyword argument '%s'"
 653                    " to method delete_custom_settings" % key
 654                )
 655            params[key] = val
 656        del params['kwargs']
 657        # verify the required parameter 'account_id' is set
 658        if ('account_id' not in params) or (params['account_id'] is None):
 659            raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_settings`")
 660        # verify the required parameter 'user_id' is set
 661        if ('user_id' not in params) or (params['user_id'] is None):
 662            raise ValueError("Missing the required parameter `user_id` when calling `delete_custom_settings`")
 663
 664
 665        collection_formats = {}
 666
 667        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/custom_settings'.replace('{format}', 'json')
 668        path_params = {}
 669        if 'account_id' in params:
 670            path_params['accountId'] = params['account_id']
 671        if 'user_id' in params:
 672            path_params['userId'] = params['user_id']
 673
 674        query_params = {}
 675
 676        header_params = {}
 677
 678        form_params = []
 679        local_var_files = {}
 680
 681        body_params = None
 682        if 'custom_settings_information' in params:
 683            body_params = params['custom_settings_information']
 684        # HTTP header `Accept`
 685        header_params['Accept'] = self.api_client.\
 686            select_header_accept(['application/json'])
 687
 688        # Authentication setting
 689        auth_settings = []
 690
 691        return self.api_client.call_api(resource_path, 'DELETE',
 692                                        path_params,
 693                                        query_params,
 694                                        header_params,
 695                                        body=body_params,
 696                                        post_params=form_params,
 697                                        files=local_var_files,
 698                                        response_type='CustomSettingsInformation',
 699                                        auth_settings=auth_settings,
 700                                        callback=params.get('callback'),
 701                                        _return_http_data_only=params.get('_return_http_data_only'),
 702                                        _preload_content=params.get('_preload_content', True),
 703                                        _request_timeout=params.get('_request_timeout'),
 704                                        collection_formats=collection_formats)
 705
 706    def delete_profile_image(self, account_id, user_id, **kwargs):
 707        """
 708        Deletes the user profile image for the specified user.
 709        Deletes the user profile image from the  specified user's profile.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the specified account.
 710        This method makes a synchronous HTTP request by default. To make an
 711        asynchronous HTTP request, please define a `callback` function
 712        to be invoked when receiving the response.
 713        >>> def callback_function(response):
 714        >>>     pprint(response)
 715        >>>
 716        >>> thread = api.delete_profile_image(account_id, user_id, callback=callback_function)
 717
 718        :param callback function: The callback function
 719            for asynchronous request. (optional)
 720        :param str account_id: The external account number (int) or account ID Guid. (required)
 721        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 722        :return: None
 723                 If the method is called asynchronously,
 724                 returns the request thread.
 725        """
 726        kwargs['_return_http_data_only'] = True
 727        if kwargs.get('callback'):
 728            return self.delete_profile_image_with_http_info(account_id, user_id, **kwargs)
 729        else:
 730            (data) = self.delete_profile_image_with_http_info(account_id, user_id, **kwargs)
 731            return data
 732
 733    def delete_profile_image_with_http_info(self, account_id, user_id, **kwargs):
 734        """
 735        Deletes the user profile image for the specified user.
 736        Deletes the user profile image from the  specified user's profile.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the specified account.
 737        This method makes a synchronous HTTP request by default. To make an
 738        asynchronous HTTP request, please define a `callback` function
 739        to be invoked when receiving the response.
 740        >>> def callback_function(response):
 741        >>>     pprint(response)
 742        >>>
 743        >>> thread = api.delete_profile_image_with_http_info(account_id, user_id, callback=callback_function)
 744
 745        :param callback function: The callback function
 746            for asynchronous request. (optional)
 747        :param str account_id: The external account number (int) or account ID Guid. (required)
 748        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 749        :return: None
 750                 If the method is called asynchronously,
 751                 returns the request thread.
 752        """
 753
 754        all_params = ['account_id', 'user_id']
 755        all_params.append('callback')
 756        all_params.append('_return_http_data_only')
 757        all_params.append('_preload_content')
 758        all_params.append('_request_timeout')
 759
 760        params = locals()
 761        for key, val in iteritems(params['kwargs']):
 762            if key not in all_params:
 763                raise TypeError(
 764                    "Got an unexpected keyword argument '%s'"
 765                    " to method delete_profile_image" % key
 766                )
 767            params[key] = val
 768        del params['kwargs']
 769        # verify the required parameter 'account_id' is set
 770        if ('account_id' not in params) or (params['account_id'] is None):
 771            raise ValueError("Missing the required parameter `account_id` when calling `delete_profile_image`")
 772        # verify the required parameter 'user_id' is set
 773        if ('user_id' not in params) or (params['user_id'] is None):
 774            raise ValueError("Missing the required parameter `user_id` when calling `delete_profile_image`")
 775
 776
 777        collection_formats = {}
 778
 779        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/profile/image'.replace('{format}', 'json')
 780        path_params = {}
 781        if 'account_id' in params:
 782            path_params['accountId'] = params['account_id']
 783        if 'user_id' in params:
 784            path_params['userId'] = params['user_id']
 785
 786        query_params = {}
 787
 788        header_params = {}
 789
 790        form_params = []
 791        local_var_files = {}
 792
 793        body_params = None
 794        # HTTP header `Accept`
 795        header_params['Accept'] = self.api_client.\
 796            select_header_accept(['application/json'])
 797
 798        # Authentication setting
 799        auth_settings = []
 800
 801        return self.api_client.call_api(resource_path, 'DELETE',
 802                                        path_params,
 803                                        query_params,
 804                                        header_params,
 805                                        body=body_params,
 806                                        post_params=form_params,
 807                                        files=local_var_files,
 808                                        response_type=None,
 809                                        auth_settings=auth_settings,
 810                                        callback=params.get('callback'),
 811                                        _return_http_data_only=params.get('_return_http_data_only'),
 812                                        _preload_content=params.get('_preload_content', True),
 813                                        _request_timeout=params.get('_request_timeout'),
 814                                        collection_formats=collection_formats)
 815
 816    def delete_signature(self, account_id, signature_id, user_id, **kwargs):
 817        """
 818        Removes removes signature information for the specified user.
 819        Removes the signature information for the user.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
 820        This method makes a synchronous HTTP request by default. To make an
 821        asynchronous HTTP request, please define a `callback` function
 822        to be invoked when receiving the response.
 823        >>> def callback_function(response):
 824        >>>     pprint(response)
 825        >>>
 826        >>> thread = api.delete_signature(account_id, signature_id, user_id, callback=callback_function)
 827
 828        :param callback function: The callback function
 829            for asynchronous request. (optional)
 830        :param str account_id: The external account number (int) or account ID Guid. (required)
 831        :param str signature_id: The ID of the signature being accessed. (required)
 832        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 833        :return: None
 834                 If the method is called asynchronously,
 835                 returns the request thread.
 836        """
 837        kwargs['_return_http_data_only'] = True
 838        if kwargs.get('callback'):
 839            return self.delete_signature_with_http_info(account_id, signature_id, user_id, **kwargs)
 840        else:
 841            (data) = self.delete_signature_with_http_info(account_id, signature_id, user_id, **kwargs)
 842            return data
 843
 844    def delete_signature_with_http_info(self, account_id, signature_id, user_id, **kwargs):
 845        """
 846        Removes removes signature information for the specified user.
 847        Removes the signature information for the user.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
 848        This method makes a synchronous HTTP request by default. To make an
 849        asynchronous HTTP request, please define a `callback` function
 850        to be invoked when receiving the response.
 851        >>> def callback_function(response):
 852        >>>     pprint(response)
 853        >>>
 854        >>> thread = api.delete_signature_with_http_info(account_id, signature_id, user_id, callback=callback_function)
 855
 856        :param callback function: The callback function
 857            for asynchronous request. (optional)
 858        :param str account_id: The external account number (int) or account ID Guid. (required)
 859        :param str signature_id: The ID of the signature being accessed. (required)
 860        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 861        :return: None
 862                 If the method is called asynchronously,
 863                 returns the request thread.
 864        """
 865
 866        all_params = ['account_id', 'signature_id', 'user_id']
 867        all_params.append('callback')
 868        all_params.append('_return_http_data_only')
 869        all_params.append('_preload_content')
 870        all_params.append('_request_timeout')
 871
 872        params = locals()
 873        for key, val in iteritems(params['kwargs']):
 874            if key not in all_params:
 875                raise TypeError(
 876                    "Got an unexpected keyword argument '%s'"
 877                    " to method delete_signature" % key
 878                )
 879            params[key] = val
 880        del params['kwargs']
 881        # verify the required parameter 'account_id' is set
 882        if ('account_id' not in params) or (params['account_id'] is None):
 883            raise ValueError("Missing the required parameter `account_id` when calling `delete_signature`")
 884        # verify the required parameter 'signature_id' is set
 885        if ('signature_id' not in params) or (params['signature_id'] is None):
 886            raise ValueError("Missing the required parameter `signature_id` when calling `delete_signature`")
 887        # verify the required parameter 'user_id' is set
 888        if ('user_id' not in params) or (params['user_id'] is None):
 889            raise ValueError("Missing the required parameter `user_id` when calling `delete_signature`")
 890
 891
 892        collection_formats = {}
 893
 894        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures/{signatureId}'.replace('{format}', 'json')
 895        path_params = {}
 896        if 'account_id' in params:
 897            path_params['accountId'] = params['account_id']
 898        if 'signature_id' in params:
 899            path_params['signatureId'] = params['signature_id']
 900        if 'user_id' in params:
 901            path_params['userId'] = params['user_id']
 902
 903        query_params = {}
 904
 905        header_params = {}
 906
 907        form_params = []
 908        local_var_files = {}
 909
 910        body_params = None
 911        # HTTP header `Accept`
 912        header_params['Accept'] = self.api_client.\
 913            select_header_accept(['application/json'])
 914
 915        # Authentication setting
 916        auth_settings = []
 917
 918        return self.api_client.call_api(resource_path, 'DELETE',
 919                                        path_params,
 920                                        query_params,
 921                                        header_params,
 922                                        body=body_params,
 923                                        post_params=form_params,
 924                                        files=local_var_files,
 925                                        response_type=None,
 926                                        auth_settings=auth_settings,
 927                                        callback=params.get('callback'),
 928                                        _return_http_data_only=params.get('_return_http_data_only'),
 929                                        _preload_content=params.get('_preload_content', True),
 930                                        _request_timeout=params.get('_request_timeout'),
 931                                        collection_formats=collection_formats)
 932
 933    def delete_signature_image(self, account_id, image_type, signature_id, user_id, **kwargs):
 934        """
 935        Deletes the user initials image or the  user signature image for the specified user.
 936        Deletes the specified initials image or signature image for the specified user.  The function deletes one or the other of the image types, to delete both the initials image and signature image you must call the endpoint twice.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
 937        This method makes a synchronous HTTP request by default. To make an
 938        asynchronous HTTP request, please define a `callback` function
 939        to be invoked when receiving the response.
 940        >>> def callback_function(response):
 941        >>>     pprint(response)
 942        >>>
 943        >>> thread = api.delete_signature_image(account_id, image_type, signature_id, user_id, callback=callback_function)
 944
 945        :param callback function: The callback function
 946            for asynchronous request. (optional)
 947        :param str account_id: The external account number (int) or account ID Guid. (required)
 948        :param str image_type: One of **signature_image** or **initials_image**. (required)
 949        :param str signature_id: The ID of the signature being accessed. (required)
 950        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 951        :return: UserSignature
 952                 If the method is called asynchronously,
 953                 returns the request thread.
 954        """
 955        kwargs['_return_http_data_only'] = True
 956        if kwargs.get('callback'):
 957            return self.delete_signature_image_with_http_info(account_id, image_type, signature_id, user_id, **kwargs)
 958        else:
 959            (data) = self.delete_signature_image_with_http_info(account_id, image_type, signature_id, user_id, **kwargs)
 960            return data
 961
 962    def delete_signature_image_with_http_info(self, account_id, image_type, signature_id, user_id, **kwargs):
 963        """
 964        Deletes the user initials image or the  user signature image for the specified user.
 965        Deletes the specified initials image or signature image for the specified user.  The function deletes one or the other of the image types, to delete both the initials image and signature image you must call the endpoint twice.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
 966        This method makes a synchronous HTTP request by default. To make an
 967        asynchronous HTTP request, please define a `callback` function
 968        to be invoked when receiving the response.
 969        >>> def callback_function(response):
 970        >>>     pprint(response)
 971        >>>
 972        >>> thread = api.delete_signature_image_with_http_info(account_id, image_type, signature_id, user_id, callback=callback_function)
 973
 974        :param callback function: The callback function
 975            for asynchronous request. (optional)
 976        :param str account_id: The external account number (int) or account ID Guid. (required)
 977        :param str image_type: One of **signature_image** or **initials_image**. (required)
 978        :param str signature_id: The ID of the signature being accessed. (required)
 979        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 980        :return: UserSignature
 981                 If the method is called asynchronously,
 982                 returns the request thread.
 983        """
 984
 985        all_params = ['account_id', 'image_type', 'signature_id', 'user_id']
 986        all_params.append('callback')
 987        all_params.append('_return_http_data_only')
 988        all_params.append('_preload_content')
 989        all_params.append('_request_timeout')
 990
 991        params = locals()
 992        for key, val in iteritems(params['kwargs']):
 993            if key not in all_params:
 994                raise TypeError(
 995                    "Got an unexpected keyword argument '%s'"
 996                    " to method delete_signature_image" % key
 997                )
 998            params[key] = val
 999        del params['kwargs']
1000        # verify the required parameter 'account_id' is set
1001        if ('account_id' not in params) or (params['account_id'] is None):
1002            raise ValueError("Missing the required parameter `account_id` when calling `delete_signature_image`")
1003        # verify the required parameter 'image_type' is set
1004        if ('image_type' not in params) or (params['image_type'] is None):
1005            raise ValueError("Missing the required parameter `image_type` when calling `delete_signature_image`")
1006        # verify the required parameter 'signature_id' is set
1007        if ('signature_id' not in params) or (params['signature_id'] is None):
1008            raise ValueError("Missing the required parameter `signature_id` when calling `delete_signature_image`")
1009        # verify the required parameter 'user_id' is set
1010        if ('user_id' not in params) or (params['user_id'] is None):
1011            raise ValueError("Missing the required parameter `user_id` when calling `delete_signature_image`")
1012
1013
1014        collection_formats = {}
1015
1016        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
1017        path_params = {}
1018        if 'account_id' in params:
1019            path_params['accountId'] = params['account_id']
1020        if 'image_type' in params:
1021            path_params['imageType'] = params['image_type']
1022        if 'signature_id' in params:
1023            path_params['signatureId'] = params['signature_id']
1024        if 'user_id' in params:
1025            path_params['userId'] = params['user_id']
1026
1027        query_params = {}
1028
1029        header_params = {}
1030
1031        form_params = []
1032        local_var_files = {}
1033
1034        body_params = None
1035        # HTTP header `Accept`
1036        header_params['Accept'] = self.api_client.\
1037            select_header_accept(['application/json'])
1038
1039        # Authentication setting
1040        auth_settings = []
1041
1042        return self.api_client.call_api(resource_path, 'DELETE',
1043                                        path_params,
1044                                        query_params,
1045                                        header_params,
1046                                        body=body_params,
1047                                        post_params=form_params,
1048                                        files=local_var_files,
1049                                        response_type='UserSignature',
1050                                        auth_settings=auth_settings,
1051                                        callback=params.get('callback'),
1052                                        _return_http_data_only=params.get('_return_http_data_only'),
1053                                        _preload_content=params.get('_preload_content', True),
1054                                        _request_timeout=params.get('_request_timeout'),
1055                                        collection_formats=collection_formats)
1056
1057    def get_contact_by_id(self, account_id, contact_id, **kwargs):
1058        """
1059        Gets a particular contact associated with the user's account.
1060        This method returns one or more contacts associated with a DocuSign account. You can also retrieve contacts from connected [cloud storage][CloudStorage] providers by using the `cloud_provider` query parameter. By default, contacts are retrieved from the DocuSign account's default address book.  To return a specific contact, use the `contactId` query parameter. To return all contacts associated with an account, omit this parameter.  [CloudStorage]: /docs/esign-rest-api/reference/cloudstorage/
1061        This method makes a synchronous HTTP request by default. To make an
1062        asynchronous HTTP request, please define a `callback` function
1063        to be invoked when receiving the response.
1064        >>> def callback_function(response):
1065        >>>     pprint(response)
1066        >>>
1067        >>> thread = api.get_contact_by_id(account_id, contact_id, callback=callback_function)
1068
1069        :param callback function: The callback function
1070            for asynchronous request. (optional)
1071        :param str account_id: The external account number (int) or account ID Guid. (required)
1072        :param str contact_id: The unique identifier of a person in the contacts address book. (required)
1073        :param str cloud_provider:
1074        :return: ContactGetResponse
1075                 If the method is called asynchronously,
1076                 returns the request thread.
1077        """
1078        kwargs['_return_http_data_only'] = True
1079        if kwargs.get('callback'):
1080            return self.get_contact_by_id_with_http_info(account_id, contact_id, **kwargs)
1081        else:
1082            (data) = self.get_contact_by_id_with_http_info(account_id, contact_id, **kwargs)
1083            return data
1084
1085    def get_contact_by_id_with_http_info(self, account_id, contact_id, **kwargs):
1086        """
1087        Gets a particular contact associated with the user's account.
1088        This method returns one or more contacts associated with a DocuSign account. You can also retrieve contacts from connected [cloud storage][CloudStorage] providers by using the `cloud_provider` query parameter. By default, contacts are retrieved from the DocuSign account's default address book.  To return a specific contact, use the `contactId` query parameter. To return all contacts associated with an account, omit this parameter.  [CloudStorage]: /docs/esign-rest-api/reference/cloudstorage/
1089        This method makes a synchronous HTTP request by default. To make an
1090        asynchronous HTTP request, please define a `callback` function
1091        to be invoked when receiving the response.
1092        >>> def callback_function(response):
1093        >>>     pprint(response)
1094        >>>
1095        >>> thread = api.get_contact_by_id_with_http_info(account_id, contact_id, callback=callback_function)
1096
1097        :param callback function: The callback function
1098            for asynchronous request. (optional)
1099        :param str account_id: The external account number (int) or account ID Guid. (required)
1100        :param str contact_id: The unique identifier of a person in the contacts address book. (required)
1101        :param str cloud_provider:
1102        :return: ContactGetResponse
1103                 If the method is called asynchronously,
1104                 returns the request thread.
1105        """
1106
1107        all_params = ['account_id', 'contact_id', 'cloud_provider']
1108        all_params.append('callback')
1109        all_params.append('_return_http_data_only')
1110        all_params.append('_preload_content')
1111        all_params.append('_request_timeout')
1112
1113        params = locals()
1114        for key, val in iteritems(params['kwargs']):
1115            if key not in all_params:
1116                raise TypeError(
1117                    "Got an unexpected keyword argument '%s'"
1118                    " to method get_contact_by_id" % key
1119                )
1120            params[key] = val
1121        del params['kwargs']
1122        # verify the required parameter 'account_id' is set
1123        if ('account_id' not in params) or (params['account_id'] is None):
1124            raise ValueError("Missing the required parameter `account_id` when calling `get_contact_by_id`")
1125        # verify the required parameter 'contact_id' is set
1126        if ('contact_id' not in params) or (params['contact_id'] is None):
1127            raise ValueError("Missing the required parameter `contact_id` when calling `get_contact_by_id`")
1128
1129
1130        collection_formats = {}
1131
1132        resource_path = '/v2.1/accounts/{accountId}/contacts/{contactId}'.replace('{format}', 'json')
1133        path_params = {}
1134        if 'account_id' in params:
1135            path_params['accountId'] = params['account_id']
1136        if 'contact_id' in params:
1137            path_params['contactId'] = params['contact_id']
1138
1139        query_params = {}
1140        if 'cloud_provider' in params:
1141            query_params['cloud_provider'] = params['cloud_provider']
1142
1143        header_params = {}
1144
1145        form_params = []
1146        local_var_files = {}
1147
1148        body_params = None
1149        # HTTP header `Accept`
1150        header_params['Accept'] = self.api_client.\
1151            select_header_accept(['application/json'])
1152
1153        # Authentication setting
1154        auth_settings = []
1155
1156        return self.api_client.call_api(resource_path, 'GET',
1157                                        path_params,
1158                                        query_params,
1159                                        header_params,
1160                                        body=body_params,
1161                                        post_params=form_params,
1162                                        files=local_var_files,
1163                                        response_type='ContactGetResponse',
1164                                        auth_settings=auth_settings,
1165                                        callback=params.get('callback'),
1166                                        _return_http_data_only=params.get('_return_http_data_only'),
1167                                        _preload_content=params.get('_preload_content', True),
1168                                        _request_timeout=params.get('_request_timeout'),
1169                                        collection_formats=collection_formats)
1170
1171    def get_information(self, account_id, user_id, **kwargs):
1172        """
1173        Gets the user information for a specified user.
1174        Retrieves the user information for the specified user.   To return additional user information that details the last login date, login status, and the user's password expiration date, set the optional `additional_info` query string parameter to **true**.
1175        This method makes a synchronous HTTP request by default. To make an
1176        asynchronous HTTP request, please define a `callback` function
1177        to be invoked when receiving the response.
1178        >>> def callback_function(response):
1179        >>>     pprint(response)
1180        >>>
1181        >>> thread = api.get_information(account_id, user_id, callback=callback_function)
1182
1183        :param callback function: The callback function
1184            for asynchronous request. (optional)
1185        :param str account_id: The external account number (int) or account ID Guid. (required)
1186        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1187        :param str additional_info: When set to **true**, the full list of user information is returned for each user in the account.
1188        :param str email:
1189        :return: UserInformation
1190                 If the method is called asynchronously,
1191                 returns the request thread.
1192        """
1193        kwargs['_return_http_data_only'] = True
1194        if kwargs.get('callback'):
1195            return self.get_information_with_http_info(account_id, user_id, **kwargs)
1196        else:
1197            (data) = self.get_information_with_http_info(account_id, user_id, **kwargs)
1198            return data
1199
1200    def get_information_with_http_info(self, account_id, user_id, **kwargs):
1201        """
1202        Gets the user information for a specified user.
1203        Retrieves the user information for the specified user.   To return additional user information that details the last login date, login status, and the user's password expiration date, set the optional `additional_info` query string parameter to **true**.
1204        This method makes a synchronous HTTP request by default. To make an
1205        asynchronous HTTP request, please define a `callback` function
1206        to be invoked when receiving the response.
1207        >>> def callback_function(response):
1208        >>>     pprint(response)
1209        >>>
1210        >>> thread = api.get_information_with_http_info(account_id, user_id, callback=callback_function)
1211
1212        :param callback function: The callback function
1213            for asynchronous request. (optional)
1214        :param str account_id: The external account number (int) or account ID Guid. (required)
1215        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1216        :param str additional_info: When set to **true**, the full list of user information is returned for each user in the account.
1217        :param str email:
1218        :return: UserInformation
1219                 If the method is called asynchronously,
1220                 returns the request thread.
1221        """
1222
1223        all_params = ['account_id', 'user_id', 'additional_info', 'email']
1224        all_params.append('callback')
1225        all_params.append('_return_http_data_only')
1226        all_params.append('_preload_content')
1227        all_params.append('_request_timeout')
1228
1229        params = locals()
1230        for key, val in iteritems(params['kwargs']):
1231            if key not in all_params:
1232                raise TypeError(
1233                    "Got an unexpected keyword argument '%s'"
1234                    " to method get_information" % key
1235                )
1236            params[key] = val
1237        del params['kwargs']
1238        # verify the required parameter 'account_id' is set
1239        if ('account_id' not in params) or (params['account_id'] is None):
1240            raise ValueError("Missing the required parameter `account_id` when calling `get_information`")
1241        # verify the required parameter 'user_id' is set
1242        if ('user_id' not in params) or (params['user_id'] is None):
1243            raise ValueError("Missing the required parameter `user_id` when calling `get_information`")
1244
1245
1246        collection_formats = {}
1247
1248        resource_path = '/v2.1/accounts/{accountId}/users/{userId}'.replace('{format}', 'json')
1249        path_params = {}
1250        if 'account_id' in params:
1251            path_params['accountId'] = params['account_id']
1252        if 'user_id' in params:
1253            path_params['userId'] = params['user_id']
1254
1255        query_params = {}
1256        if 'additional_info' in params:
1257            query_params['additional_info'] = params['additional_info']
1258        if 'email' in params:
1259            query_params['email'] = params['email']
1260
1261        header_params = {}
1262
1263        form_params = []
1264        local_var_files = {}
1265
1266        body_params = None
1267        # HTTP header `Accept`
1268        header_params['Accept'] = self.api_client.\
1269            select_header_accept(['application/json'])
1270
1271        # Authentication setting
1272        auth_settings = []
1273
1274        return self.api_client.call_api(resource_path, 'GET',
1275                                        path_params,
1276                                        query_params,
1277                                        header_params,
1278                                        body=body_params,
1279                                        post_params=form_params,
1280                                        files=local_var_files,
1281                                        response_type='UserInformation',
1282                                        auth_settings=auth_settings,
1283                                        callback=params.get('callback'),
1284                                        _return_http_data_only=params.get('_return_http_data_only'),
1285                                        _preload_content=params.get('_preload_content', True),
1286                                        _request_timeout=params.get('_request_timeout'),
1287                                        collection_formats=collection_formats)
1288
1289    def get_profile(self, account_id, user_id, **kwargs):
1290        """
1291        Retrieves the user profile for a specified user.
1292        Retrieves the user profile information, the privacy settings and personal information (address, phone number, etc.) for the specified user.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the specified account.
1293        This method makes a synchronous HTTP request by default. To make an
1294        asynchronous HTTP request, please define a `callback` function
1295        to be invoked when receiving the response.
1296        >>> def callback_function(response):
1297        >>>     pprint(response)
1298        >>>
1299        >>> thread = api.get_profile(account_id, user_id, callback=callback_function)
1300
1301        :param callback function: The callback function
1302            for asynchronous request. (optional)
1303        :param str account_id: The external account number (int) or account ID Guid. (required)
1304        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1305        :return: UserProfile
1306                 If the method is called asynchronously,
1307                 returns the request thread.
1308        """
1309        kwargs['_return_http_data_only'] = True
1310        if kwargs.get('callback'):
1311            return self.get_profile_with_http_info(account_id, user_id, **kwargs)
1312        else:
1313            (data) = self.get_profile_with_http_info(account_id, user_id, **kwargs)
1314            return data
1315
1316    def get_profile_with_http_info(self, account_id, user_id, **kwargs):
1317        """
1318        Retrieves the user profile for a specified user.
1319        Retrieves the user profile information, the privacy settings and personal information (address, phone number, etc.) for the specified user.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the specified account.
1320        This method makes a synchronous HTTP request by default. To make an
1321        asynchronous HTTP request, please define a `callback` function
1322        to be invoked when receiving the response.
1323        >>> def callback_function(response):
1324        >>>     pprint(response)
1325        >>>
1326        >>> thread = api.get_profile_with_http_info(account_id, user_id, callback=callback_function)
1327
1328        :param callback function: The callback function
1329            for asynchronous request. (optional)
1330        :param str account_id: The external account number (int) or account ID Guid. (required)
1331        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1332        :return: UserProfile
1333                 If the method is called asynchronously,
1334                 returns the request thread.
1335        """
1336
1337        all_params = ['account_id', 'user_id']
1338        all_params.append('callback')
1339        all_params.append('_return_http_data_only')
1340        all_params.append('_preload_content')
1341        all_params.append('_request_timeout')
1342
1343        params = locals()
1344        for key, val in iteritems(params['kwargs']):
1345            if key not in all_params:
1346                raise TypeError(
1347                    "Got an unexpected keyword argument '%s'"
1348                    " to method get_profile" % key
1349                )
1350            params[key] = val
1351        del params['kwargs']
1352        # verify the required parameter 'account_id' is set
1353        if ('account_id' not in params) or (params['account_id'] is None):
1354            raise ValueError("Missing the required parameter `account_id` when calling `get_profile`")
1355        # verify the required parameter 'user_id' is set
1356        if ('user_id' not in params) or (params['user_id'] is None):
1357            raise ValueError("Missing the required parameter `user_id` when calling `get_profile`")
1358
1359
1360        collection_formats = {}
1361
1362        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/profile'.replace('{format}', 'json')
1363        path_params = {}
1364        if 'account_id' in params:
1365            path_params['accountId'] = params['account_id']
1366        if 'user_id' in params:
1367            path_params['userId'] = params['user_id']
1368
1369        query_params = {}
1370
1371        header_params = {}
1372
1373        form_params = []
1374        local_var_files = {}
1375
1376        body_params = None
1377        # HTTP header `Accept`
1378        header_params['Accept'] = self.api_client.\
1379            select_header_accept(['application/json'])
1380
1381        # Authentication setting
1382        auth_settings = []
1383
1384        return self.api_client.call_api(resource_path, 'GET',
1385                                        path_params,
1386                                        query_params,
1387                                        header_params,
1388                                        body=body_params,
1389                                        post_params=form_params,
1390                                        files=local_var_files,
1391                                        response_type='UserProfile',
1392                                        auth_settings=auth_settings,
1393                                        callback=params.get('callback'),
1394                                        _return_http_data_only=params.get('_return_http_data_only'),
1395                                        _preload_content=params.get('_preload_content', True),
1396                                        _request_timeout=params.get('_request_timeout'),
1397                                        collection_formats=collection_formats)
1398
1399    def get_profile_image(self, account_id, user_id, **kwargs):
1400        """
1401        Retrieves the user profile image for the specified user.
1402        Retrieves the user profile picture for the specified user. The image is returned in the same format as uploaded.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the specified account.  If successful, the response returns a 200 - OK and the user profile image.
1403        This method makes a synchronous HTTP request by default. To make an
1404        asynchronous HTTP request, please define a `callback` function
1405        to be invoked when receiving the response.
1406        >>> def callback_function(response):
1407        >>>     pprint(response)
1408        >>>
1409        >>> thread = api.get_profile_image(account_id, user_id, callback=callback_function)
1410
1411        :param callback function: The callback function
1412            for asynchronous request. (optional)
1413        :param str account_id: The external account number (int) or account ID Guid. (required)
1414        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1415        :param str encoding:
1416        :return: file
1417                 If the method is called asynchronously,
1418                 returns the request thread.
1419        """
1420        kwargs['_return_http_data_only'] = True
1421        if kwargs.get('callback'):
1422            return self.get_profile_image_with_http_info(account_id, user_id, **kwargs)
1423        else:
1424            (data) = self.get_profile_image_with_http_info(account_id, user_id, **kwargs)
1425            return data
1426
1427    def get_profile_image_with_http_info(self, account_id, user_id, **kwargs):
1428        """
1429        Retrieves the user profile image for the specified user.
1430        Retrieves the user profile picture for the specified user. The image is returned in the same format as uploaded.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the specified account.  If successful, the response returns a 200 - OK and the user profile image.
1431        This method makes a synchronous HTTP request by default. To make an
1432        asynchronous HTTP request, please define a `callback` function
1433        to be invoked when receiving the response.
1434        >>> def callback_function(response):
1435        >>>     pprint(response)
1436        >>>
1437        >>> thread = api.get_profile_image_with_http_info(account_id, user_id, callback=callback_function)
1438
1439        :param callback function: The callback function
1440            for asynchronous request. (optional)
1441        :param str account_id: The external account number (int) or account ID Guid. (required)
1442        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1443        :param str encoding:
1444        :return: file
1445                 If the method is called asynchronously,
1446                 returns the request thread.
1447        """
1448
1449        all_params = ['account_id', 'user_id', 'encoding']
1450        all_params.append('callback')
1451        all_params.append('_return_http_data_only')
1452        all_params.append('_preload_content')
1453        all_params.append('_request_timeout')
1454
1455        params = locals()
1456        for key, val in iteritems(params['kwargs']):
1457            if key not in all_params:
1458                raise TypeError(
1459                    "Got an unexpected keyword argument '%s'"
1460                    " to method get_profile_image" % key
1461                )
1462            params[key] = val
1463        del params['kwargs']
1464        # verify the required parameter 'account_id' is set
1465        if ('account_id' not in params) or (params['account_id'] is None):
1466            raise ValueError("Missing the required parameter `account_id` when calling `get_profile_image`")
1467        # verify the required parameter 'user_id' is set
1468        if ('user_id' not in params) or (params['user_id'] is None):
1469            raise ValueError("Missing the required parameter `user_id` when calling `get_profile_image`")
1470
1471
1472        collection_formats = {}
1473
1474        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/profile/image'.replace('{format}', 'json')
1475        path_params = {}
1476        if 'account_id' in params:
1477            path_params['accountId'] = params['account_id']
1478        if 'user_id' in params:
1479            path_params['userId'] = params['user_id']
1480
1481        query_params = {}
1482        if 'encoding' in params:
1483            query_params['encoding'] = params['encoding']
1484
1485        header_params = {}
1486
1487        form_params = []
1488        local_var_files = {}
1489
1490        body_params = None
1491        # HTTP header `Accept`
1492        header_params['Accept'] = self.api_client.\
1493            select_header_accept(['image/gif'])
1494
1495        # Authentication setting
1496        auth_settings = []
1497
1498        return self.api_client.call_api(resource_path, 'GET',
1499                                        path_params,
1500                                        query_params,
1501                                        header_params,
1502                                        body=body_params,
1503                                        post_params=form_params,
1504                                        files=local_var_files,
1505                                        response_type='file',
1506                                        auth_settings=auth_settings,
1507                                        callback=params.get('callback'),
1508                                        _return_http_data_only=params.get('_return_http_data_only'),
1509                                        _preload_content=params.get('_preload_content', True),
1510                                        _request_timeout=params.get('_request_timeout'),
1511                                        collection_formats=collection_formats)
1512
1513    def get_settings(self, account_id, user_id, **kwargs):
1514        """
1515        Gets the user account settings for a specified user.
1516        Retrieves a list of the account settings and email notification information for the specified user.  The response returns the account setting name/value information and the email notification settings for the specified user. For more information about the different user settings, see the [ML:userSettings list].
1517        This method makes a synchronous HTTP request by default. To make an
1518        asynchronous HTTP request, please define a `callback` function
1519        to be invoked when receiving the response.
1520        >>> def callback_function(response):
1521        >>>     pprint(response)
1522        >>>
1523        >>> thread = api.get_settings(account_id, user_id, callback=callback_function)
1524
1525        :param callback function: The callback function
1526            for asynchronous request. (optional)
1527        :param str account_id: The external account number (int) or account ID Guid. (required)
1528        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1529        :return: UserSettingsInformation
1530                 If the method is called asynchronously,
1531                 returns the request thread.
1532        """
1533        kwargs['_return_http_data_only'] = True
1534        if kwargs.get('callback'):
1535            return self.get_settings_with_http_info(account_id, user_id, **kwargs)
1536        else:
1537            (data) = self.get_settings_with_http_info(account_id, user_id, **kwargs)
1538            return data
1539
1540    def get_settings_with_http_info(self, account_id, user_id, **kwargs):
1541        """
1542        Gets the user account settings for a specified user.
1543        Retrieves a list of the account settings and email notification information for the specified user.  The response returns the account setting name/value information and the email notification settings for the specified user. For more information about the different user settings, see the [ML:userSettings list].
1544        This method makes a synchronous HTTP request by default. To make an
1545        asynchronous HTTP request, please define a `callback` function
1546        to be invoked when receiving the response.
1547        >>> def callback_function(response):
1548        >>>     pprint(response)
1549        >>>
1550        >>> thread = api.get_settings_with_http_info(account_id, user_id, callback=callback_function)
1551
1552        :param callback function: The callback function
1553            for asynchronous request. (optional)
1554        :param str account_id: The external account number (int) or account ID Guid. (required)
1555        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1556        :return: UserSettingsInformation
1557                 If the method is called asynchronously,
1558                 returns the request thread.
1559        """
1560
1561        all_params = ['account_id', 'user_id']
1562        all_params.append('callback')
1563        all_params.append('_return_http_data_only')
1564        all_params.append('_preload_content')
1565        all_params.append('_request_timeout')
1566
1567        params = locals()
1568        for key, val in iteritems(params['kwargs']):
1569            if key not in all_params:
1570                raise TypeError(
1571                    "Got an unexpected keyword argument '%s'"
1572                    " to method get_settings" % key
1573                )
1574            params[key] = val
1575        del params['kwargs']
1576        # verify the required parameter 'account_id' is set
1577        if ('account_id' not in params) or (params['account_id'] is None):
1578            raise ValueError("Missing the required parameter `account_id` when calling `get_settings`")
1579        # verify the required parameter 'user_id' is set
1580        if ('user_id' not in params) or (params['user_id'] is None):
1581            raise ValueError("Missing the required parameter `user_id` when calling `get_settings`")
1582
1583
1584        collection_formats = {}
1585
1586        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/settings'.replace('{format}', 'json')
1587        path_params = {}
1588        if 'account_id' in params:
1589            path_params['accountId'] = params['account_id']
1590        if 'user_id' in params:
1591            path_params['userId'] = params['user_id']
1592
1593        query_params = {}
1594
1595        header_params = {}
1596
1597        form_params = []
1598        local_var_files = {}
1599
1600        body_params = None
1601        # HTTP header `Accept`
1602        header_params['Accept'] = self.api_client.\
1603            select_header_accept(['application/json'])
1604
1605        # Authentication setting
1606        auth_settings = []
1607
1608        return self.api_client.call_api(resource_path, 'GET',
1609                                        path_params,
1610                                        query_params,
1611                                        header_params,
1612                                        body=body_params,
1613                                        post_params=form_params,
1614                                        files=local_var_files,
1615                                        response_type='UserSettingsInformation',
1616                                        auth_settings=auth_settings,
1617                                        callback=params.get('callback'),
1618                                        _return_http_data_only=params.get('_return_http_data_only'),
1619                                        _preload_content=params.get('_preload_content', True),
1620                                        _request_timeout=params.get('_request_timeout'),
1621                                        collection_formats=collection_formats)
1622
1623    def get_signature(self, account_id, signature_id, user_id, **kwargs):
1624        """
1625        Gets the user signature information for the specified user.
1626        Retrieves the structure of a single signature with a known signature name.  The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
1627        This method makes a synchronous HTTP request by default. To make an
1628        asynchronous HTTP request, please define a `callback` function
1629        to be invoked when receiving the response.
1630        >>> def callback_function(response):
1631        >>>     pprint(response)
1632        >>>
1633        >>> thread = api.get_signature(account_id, signature_id, user_id, callback=callback_function)
1634
1635        :param callback function: The callback function
1636            for asynchronous request. (optional)
1637        :param str account_id: The external account number (int) or account ID Guid. (required)
1638        :param str signature_id: The ID of the signature being accessed. (required)
1639        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1640        :return: UserSignature
1641                 If the method is called asynchronously,
1642                 returns the request thread.
1643        """
1644        kwargs['_return_http_data_only'] = True
1645        if kwargs.get('callback'):
1646            return self.get_signature_with_http_info(account_id, signature_id, user_id, **kwargs)
1647        else:
1648            (data) = self.get_signature_with_http_info(account_id, signature_id, user_id, **kwargs)
1649            return data
1650
1651    def get_signature_with_http_info(self, account_id, signature_id, user_id, **kwargs):
1652        """
1653        Gets the user signature information for the specified user.
1654        Retrieves the structure of a single signature with a known signature name.  The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
1655        This method makes a synchronous HTTP request by default. To make an
1656        asynchronous HTTP request, please define a `callback` function
1657        to be invoked when receiving the response.
1658        >>> def callback_function(response):
1659        >>>     pprint(response)
1660        >>>
1661        >>> thread = api.get_signature_with_http_info(account_id, signature_id, user_id, callback=callback_function)
1662
1663        :param callback function: The callback function
1664            for asynchronous request. (optional)
1665        :param str account_id: The external account number (int) or account ID Guid. (required)
1666        :param str signature_id: The ID of the signature being accessed. (required)
1667        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1668        :return: UserSignature
1669                 If the method is called asynchronously,
1670                 returns the request thread.
1671        """
1672
1673        all_params = ['account_id', 'signature_id', 'user_id']
1674        all_params.append('callback')
1675        all_params.append('_return_http_data_only')
1676        all_params.append('_preload_content')
1677        all_params.append('_request_timeout')
1678
1679        params = locals()
1680        for key, val in iteritems(params['kwargs']):
1681            if key not in all_params:
1682                raise TypeError(
1683                    "Got an unexpected keyword argument '%s'"
1684                    " to method get_signature" % key
1685                )
1686            params[key] = val
1687        del params['kwargs']
1688        # verify the required parameter 'account_id' is set
1689        if ('account_id' not in params) or (params['account_id'] is None):
1690            raise ValueError("Missing the required parameter `account_id` when calling `get_signature`")
1691        # verify the required parameter 'signature_id' is set
1692        if ('signature_id' not in params) or (params['signature_id'] is None):
1693            raise ValueError("Missing the required parameter `signature_id` when calling `get_signature`")
1694        # verify the required parameter 'user_id' is set
1695        if ('user_id' not in params) or (params['user_id'] is None):
1696            raise ValueError("Missing the required parameter `user_id` when calling `get_signature`")
1697
1698
1699        collection_formats = {}
1700
1701        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures/{signatureId}'.replace('{format}', 'json')
1702        path_params = {}
1703        if 'account_id' in params:
1704            path_params['accountId'] = params['account_id']
1705        if 'signature_id' in params:
1706            path_params['signatureId'] = params['signature_id']
1707        if 'user_id' in params:
1708            path_params['userId'] = params['user_id']
1709
1710        query_params = {}
1711
1712        header_params = {}
1713
1714        form_params = []
1715        local_var_files = {}
1716
1717        body_params = None
1718        # HTTP header `Accept`
1719        header_params['Accept'] = self.api_client.\
1720            select_header_accept(['application/json'])
1721
1722        # Authentication setting
1723        auth_settings = []
1724
1725        return self.api_client.call_api(resource_path, 'GET',
1726                                        path_params,
1727                                        query_params,
1728                                        header_params,
1729                                        body=body_params,
1730                                        post_params=form_params,
1731                                        files=local_var_files,
1732                                        response_type='UserSignature',
1733                                        auth_settings=auth_settings,
1734                                        callback=params.get('callback'),
1735                                        _return_http_data_only=params.get('_return_http_data_only'),
1736                                        _preload_content=params.get('_preload_content', True),
1737                                        _request_timeout=params.get('_request_timeout'),
1738                                        collection_formats=collection_formats)
1739
1740    def get_signature_image(self, account_id, image_type, signature_id, user_id, **kwargs):
1741        """
1742        Retrieves the user initials image or the  user signature image for the specified user.
1743        Retrieves the specified initials image or signature image for the specified user. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image.  The userId property specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".  ###### Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image.
1744        This method makes a synchronous HTTP request by default. To make an
1745        asynchronous HTTP request, please define a `callback` function
1746        to be invoked when receiving the response.
1747        >>> def callback_function(response):
1748        >>>     pprint(response)
1749        >>>
1750        >>> thread = api.get_signature_image(account_id, image_type, signature_id, user_id, callback=callback_function)
1751
1752        :param callback function: The callback function
1753            for asynchronous request. (optional)
1754        :param str account_id: The external account number (int) or account ID Guid. (required)
1755        :param str image_type: One of **signature_image** or **initials_image**. (required)
1756        :param str signature_id: The ID of the signature being accessed. (required)
1757        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1758        :param str include_chrome:
1759        :return: file
1760                 If the method is called asynchronously,
1761                 returns the request thread.
1762        """
1763        kwargs['_return_http_data_only'] = True
1764        if kwargs.get('callback'):
1765            return self.get_signature_image_with_http_info(account_id, image_type, signature_id, user_id, **kwargs)
1766        else:
1767            (data) = self.get_signature_image_with_http_info(account_id, image_type, signature_id, user_id, **kwargs)
1768            return data
1769
1770    def get_signature_image_with_http_info(self, account_id, image_type, signature_id, user_id, **kwargs):
1771        """
1772        Retrieves the user initials image or the  user signature image for the specified user.
1773        Retrieves the specified initials image or signature image for the specified user. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image.  The userId property specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".  ###### Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image.
1774        This method makes a synchronous HTTP request by default. To make an
1775        asynchronous HTTP request, please define a `callback` function
1776        to be invoked when receiving the response.
1777        >>> def callback_function(response):
1778        >>>     pprint(response)
1779        >>>
1780        >>> thread = api.get_signature_image_with_http_info(account_id, image_type, signature_id, user_id, callback=callback_function)
1781
1782        :param callback function: The callback function
1783            for asynchronous request. (optional)
1784        :param str account_id: The external account number (int) or account ID Guid. (required)
1785        :param str image_type: One of **signature_image** or **initials_image**. (required)
1786        :param str signature_id: The ID of the signature being accessed. (required)
1787        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
1788        :param str include_chrome:
1789        :return: file
1790                 If the method is called asynchronously,
1791                 returns the request thread.
1792        """
1793
1794        all_params = ['account_id', 'image_type', 'signature_id', 'user_id', 'include_chrome']
1795        all_params.append('callback')
1796        all_params.append('_return_http_data_only')
1797        all_params.append('_preload_content')
1798        all_params.append('_request_timeout')
1799
1800        params = locals()
1801        for key, val in iteritems(params['kwargs']):
1802            if key not in all_params:
1803                raise TypeError(
1804                    "Got an unexpected keyword argument '%s'"
1805                    " to method get_signature_image" % key
1806                )
1807            params[key] = val
1808        del params['kwargs']
1809        # verify the required parameter 'account_id' is set
1810        if ('account_id' not in params) or (params['account_id'] is None):
1811            raise ValueError("Missing the required parameter `account_id` when calling `get_signature_image`")
1812        # verify the required parameter 'image_type' is set
1813        if ('image_type' not in params) or (params['image_type'] is None):
1814            raise ValueError("Missing the required parameter `image_type` when calling `get_signature_image`")
1815        # verify the required parameter 'signature_id' is set
1816        if ('signature_id' not in params) or (params['signature_id'] is None):
1817            raise ValueError("Missing the required parameter `signature_id` when calling `get_signature_image`")
1818        # verify the required parameter 'user_id' is set
1819        if ('user_id' not in params) or (params['user_id'] is None):
1820            raise ValueError("Missing the required parameter `user_id` when calling `get_signature_image`")
1821
1822
1823        collection_formats = {}
1824
1825        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
1826        path_params = {}
1827        if 'account_id' in params:
1828            path_params['accountId'] = params['account_id']
1829        if 'image_type' in params:
1830            path_params['imageType'] = params['image_type']
1831        if 'signature_id' in params:
1832            path_params['signatureId'] = params['signature_id']
1833        if 'user_id' in params:
1834            path_params['userId'] = params['user_id']
1835
1836        query_params = {}
1837        if 'include_chrome' in params:
1838            query_params['include_chrome'] = params['include_chrome']
1839
1840        header_params = {}
1841
1842        form_params = []
1843        local_var_files = {}
1844
1845        body_params = None
1846        # HTTP header `Accept`
1847        header_params['Accept'] = self.api_client.\
1848            select_header_accept(['image/gif'])
1849
1850        # Authentication setting
1851        auth_settings = []
1852
1853        return self.api_client.call_api(resource_path, 'GET',
1854                                        path_params,
1855                                        query_params,
1856                                        header_params,
1857                                        body=body_params,
1858                                        post_params=form_params,
1859                                        files=local_var_files,
1860                                        response_type='file',
1861                                        auth_settings=auth_settings,
1862                                        callback=params.get('callback'),
1863                                        _return_http_data_only=params.get('_return_http_data_only'),
1864                                        _preload_content=params.get('_preload_content', True),
1865                                        _request_timeout=params.get('_request_timeout'),
1866                                        collection_formats=collection_formats)
1867
1868    def list(self, account_id, **kwargs):
1869        """
1870        Retrieves the list of users for the specified account.
1871        Retrieves the list of users for the specified account.  The response returns the list of users for the account along with the information about the result set. If the `additional_info` query was added to the endpoint and set to **true**, the full user information is returned for each user
1872        This method makes a synchronous HTTP request by default. To make an
1873        asynchronous HTTP request, please define a `callback` function
1874        to be invoked when receiving the response.
1875        >>> def callback_function(response):
1876        >>>     pprint(response)
1877        >>>
1878        >>> thread = api.list(account_id, callback=callback_function)
1879
1880        :param callback function: The callback function
1881            for asynchronous request. (optional)
1882        :param str account_id: The external account number (int) or account ID Guid. (required)
1883        :param str additional_info: When set to **true**, the full list of user information is returned for each user in the account.
1884        :param str alternate_admins_only:
1885        :param str count: Number of records to return. The number must be greater than 0 and less than or equal to 100. 
1886        :param str domain_users_only:
1887        :param str email:
1888        :param str email_substring: Filters the returned user records by the email address or a sub-string of email address.
1889        :param str group_id: Filters user records returned by one or more group Id's.
1890        :param str include_usersettings_for_csv:
1891        :param str login_status:
1892        :param str not_group_id:
1893        :param str start_position: Starting value for the list. 
1894        :param str status:
1895        :param str user_name_substring: Filters the user records returned by the user name or a sub-string of user name.
1896        :return: UserInformationList
1897                 If the method is called asynchronously,
1898                 returns the request thread.
1899        """
1900        kwargs['_return_http_data_only'] = True
1901        if kwargs.get('callback'):
1902            return self.list_with_http_info(account_id, **kwargs)
1903        else:
1904            (data) = self.list_with_http_info(account_id, **kwargs)
1905            return data
1906
1907    def list_with_http_info(self, account_id, **kwargs):
1908        """
1909        Retrieves the list of users for the specified account.
1910        Retrieves the list of users for the specified account.  The response returns the list of users for the account along with the information about the result set. If the `additional_info` query was added to the endpoint and set to **true**, the full user information is returned for each user
1911        This method makes a synchronous HTTP request by default. To make an
1912        asynchronous HTTP request, please define a `callback` function
1913        to be invoked when receiving the response.
1914        >>> def callback_function(response):
1915        >>>     pprint(response)
1916        >>>
1917        >>> thread = api.list_with_http_info(account_id, callback=callback_function)
1918
1919        :param callback function: The callback function
1920            for asynchronous request. (optional)
1921        :param str account_id: The external account number (int) or account ID Guid. (required)
1922        :param str additional_info: When set to **true**, the full list of user information is returned for each user in the account.
1923        :param str alternate_admins_only:
1924        :param str count: Number of records to return. The number must be greater than 0 and less than or equal to 100. 
1925        :param str domain_users_only:
1926        :param str email:
1927        :param str email_substring: Filters the returned user records by the email address or a sub-string of email address.
1928        :param str group_id: Filters user records returned by one or more group Id's.
1929        :param str include_usersettings_for_csv:
1930        :param str login_status:
1931        :param str not_group_id:
1932        :param str start_position: Starting value for the list. 
1933        :param str status:
1934        :param str user_name_substring: Filters the user records returned by the user name or a sub-string of user name.
1935        :return: UserInformationList
1936                 If the method is called asynchronously,
1937                 returns the request thread.
1938        """
1939
1940        all_params = ['account_id', 'additional_info', 'alternate_admins_only', 'count', 'domain_users_only', 'email', 'email_substring', 'group_id', 'include_usersettings_for_csv', 'login_status', 'not_group_id', 'start_position', 'status', 'user_name_substring']
1941        all_params.append('callback')
1942        all_params.append('_return_http_data_only')
1943        all_params.append('_preload_content')
1944        all_params.append('_request_timeout')
1945
1946        params = locals()
1947        for key, val in iteritems(params['kwargs']):
1948            if key not in all_params:
1949                raise TypeError(
1950                    "Got an unexpected keyword argument '%s'"
1951                    " to method list" % key
1952                )
1953            params[key] = val
1954        del params['kwargs']
1955        # verify the required parameter 'account_id' is set
1956        if ('account_id' not in params) or (params['account_id'] is None):
1957            raise ValueError("Missing the required parameter `account_id` when calling `list`")
1958
1959
1960        collection_formats = {}
1961
1962        resource_path = '/v2.1/accounts/{accountId}/users'.replace('{format}', 'json')
1963        path_params = {}
1964        if 'account_id' in params:
1965            path_params['accountId'] = params['account_id']
1966
1967        query_params = {}
1968        if 'additional_info' in params:
1969            query_params['additional_info'] = params['additional_info']
1970        if 'alternate_admins_only' in params:
1971            query_params['alternate_admins_only'] = params['alternate_admins_only']
1972        if 'count' in params:
1973            query_params['count'] = params['count']
1974        if 'domain_users_only' in params:
1975            query_params['domain_users_only'] = params['domain_users_only']
1976        if 'email' in params:
1977            query_params['email'] = params['email']
1978        if 'email_substring' in params:
1979            query_params['email_substring'] = params['email_substring']
1980        if 'group_id' in params:
1981            query_params['group_id'] = params['group_id']
1982        if 'include_usersettings_for_csv' in params:
1983            query_params['include_usersettings_for_csv'] = params['include_usersettings_for_csv']
1984        if 'login_status' in params:
1985            query_params['login_status'] = params['login_status']
1986        if 'not_group_id' in params:
1987            query_params['not_group_id'] = params['not_group_id']
1988        if 'start_position' in params:
1989            query_params['start_position'] = params['start_position']
1990        if 'status' in params:
1991            query_params['status'] = params['status']
1992        if 'user_name_substring' in params:
1993            query_params['user_name_substring'] = params['user_name_substring']
1994
1995        header_params = {}
1996
1997        form_params = []
1998        local_var_files = {}
1999
2000        body_params = None
2001        # HTTP header `Accept`
2002        header_params['Accept'] = self.api_client.\
2003            select_header_accept(['application/json'])
2004
2005        # Authentication setting
2006        auth_settings = []
2007
2008        return self.api_client.call_api(resource_path, 'GET',
2009                                        path_params,
2010                                        query_params,
2011                                        header_params,
2012                                        body=body_params,
2013                                        post_params=form_params,
2014                                        files=local_var_files,
2015                                        response_type='UserInformationList',
2016                                        auth_settings=auth_settings,
2017                                        callback=params.get('callback'),
2018                                        _return_http_data_only=params.get('_return_http_data_only'),
2019                                        _preload_content=params.get('_preload_content', True),
2020                                        _request_timeout=params.get('_request_timeout'),
2021                                        collection_formats=collection_formats)
2022
2023    def list_custom_settings(self, account_id, user_id, **kwargs):
2024        """
2025        Retrieves the custom user settings for a specified user.
2026        Retrieves a list of custom user settings for a single user.  Custom settings provide a flexible way to store and retrieve custom user information that can be used in your own system.  ###### Note: Custom user settings are not the same as user account settings.  ###Getting Grouped Custom User Settings###  If the custom user settings you want to retrieve are grouped, you must include the following information in the header, after Content-Type, in the request:  `X-DocuSign-User-Settings-Key:group_name`  Where the `group_name` is your designated name for the group of customer user settings.  If the extra header information is not included, only the custom user settings that were added without a group are retrieved.
2027        This method makes a synchronous HTTP request by default. To make an
2028        asynchronous HTTP request, please define a `callback` function
2029        to be invoked when receiving the response.
2030        >>> def callback_function(response):
2031        >>>     pprint(response)
2032        >>>
2033        >>> thread = api.list_custom_settings(account_id, user_id, callback=callback_function)
2034
2035        :param callback function: The callback function
2036            for asynchronous request. (optional)
2037        :param str account_id: The external account number (int) or account ID Guid. (required)
2038        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2039        :return: CustomSettingsInformation
2040                 If the method is called asynchronously,
2041                 returns the request thread.
2042        """
2043        kwargs['_return_http_data_only'] = True
2044        if kwargs.get('callback'):
2045            return self.list_custom_settings_with_http_info(account_id, user_id, **kwargs)
2046        else:
2047            (data) = self.list_custom_settings_with_http_info(account_id, user_id, **kwargs)
2048            return data
2049
2050    def list_custom_settings_with_http_info(self, account_id, user_id, **kwargs):
2051        """
2052        Retrieves the custom user settings for a specified user.
2053        Retrieves a list of custom user settings for a single user.  Custom settings provide a flexible way to store and retrieve custom user information that can be used in your own system.  ###### Note: Custom user settings are not the same as user account settings.  ###Getting Grouped Custom User Settings###  If the custom user settings you want to retrieve are grouped, you must include the following information in the header, after Content-Type, in the request:  `X-DocuSign-User-Settings-Key:group_name`  Where the `group_name` is your designated name for the group of customer user settings.  If the extra header information is not included, only the custom user settings that were added without a group are retrieved.
2054        This method makes a synchronous HTTP request by default. To make an
2055        asynchronous HTTP request, please define a `callback` function
2056        to be invoked when receiving the response.
2057        >>> def callback_function(response):
2058        >>>     pprint(response)
2059        >>>
2060        >>> thread = api.list_custom_settings_with_http_info(account_id, user_id, callback=callback_function)
2061
2062        :param callback function: The callback function
2063            for asynchronous request. (optional)
2064        :param str account_id: The external account number (int) or account ID Guid. (required)
2065        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2066        :return: CustomSettingsInformation
2067                 If the method is called asynchronously,
2068                 returns the request thread.
2069        """
2070
2071        all_params = ['account_id', 'user_id']
2072        all_params.append('callback')
2073        all_params.append('_return_http_data_only')
2074        all_params.append('_preload_content')
2075        all_params.append('_request_timeout')
2076
2077        params = locals()
2078        for key, val in iteritems(params['kwargs']):
2079            if key not in all_params:
2080                raise TypeError(
2081                    "Got an unexpected keyword argument '%s'"
2082                    " to method list_custom_settings" % key
2083                )
2084            params[key] = val
2085        del params['kwargs']
2086        # verify the required parameter 'account_id' is set
2087        if ('account_id' not in params) or (params['account_id'] is None):
2088            raise ValueError("Missing the required parameter `account_id` when calling `list_custom_settings`")
2089        # verify the required parameter 'user_id' is set
2090        if ('user_id' not in params) or (params['user_id'] is None):
2091            raise ValueError("Missing the required parameter `user_id` when calling `list_custom_settings`")
2092
2093
2094        collection_formats = {}
2095
2096        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/custom_settings'.replace('{format}', 'json')
2097        path_params = {}
2098        if 'account_id' in params:
2099            path_params['accountId'] = params['account_id']
2100        if 'user_id' in params:
2101            path_params['userId'] = params['user_id']
2102
2103        query_params = {}
2104
2105        header_params = {}
2106
2107        form_params = []
2108        local_var_files = {}
2109
2110        body_params = None
2111        # HTTP header `Accept`
2112        header_params['Accept'] = self.api_client.\
2113            select_header_accept(['application/json'])
2114
2115        # Authentication setting
2116        auth_settings = []
2117
2118        return self.api_client.call_api(resource_path, 'GET',
2119                                        path_params,
2120                                        query_params,
2121                                        header_params,
2122                                        body=body_params,
2123                                        post_params=form_params,
2124                                        files=local_var_files,
2125                                        response_type='CustomSettingsInformation',
2126                                        auth_settings=auth_settings,
2127                                        callback=params.get('callback'),
2128                                        _return_http_data_only=params.get('_return_http_data_only'),
2129                                        _preload_content=params.get('_preload_content', True),
2130                                        _request_timeout=params.get('_request_timeout'),
2131                                        collection_formats=collection_formats)
2132
2133    def list_signatures(self, account_id, user_id, **kwargs):
2134        """
2135        Retrieves a list of user signature definitions for a specified user.
2136        Retrieves the signature definitions for the specified user.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
2137        This method makes a synchronous HTTP request by default. To make an
2138        asynchronous HTTP request, please define a `callback` function
2139        to be invoked when receiving the response.
2140        >>> def callback_function(response):
2141        >>>     pprint(response)
2142        >>>
2143        >>> thread = api.list_signatures(account_id, user_id, callback=callback_function)
2144
2145        :param callback function: The callback function
2146            for asynchronous request. (optional)
2147        :param str account_id: The external account number (int) or account ID Guid. (required)
2148        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2149        :param str stamp_type:
2150        :return: UserSignaturesInformation
2151                 If the method is called asynchronously,
2152                 returns the request thread.
2153        """
2154        kwargs['_return_http_data_only'] = True
2155        if kwargs.get('callback'):
2156            return self.list_signatures_with_http_info(account_id, user_id, **kwargs)
2157        else:
2158            (data) = self.list_signatures_with_http_info(account_id, user_id, **kwargs)
2159            return data
2160
2161    def list_signatures_with_http_info(self, account_id, user_id, **kwargs):
2162        """
2163        Retrieves a list of user signature definitions for a specified user.
2164        Retrieves the signature definitions for the specified user.  The userId parameter specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
2165        This method makes a synchronous HTTP request by default. To make an
2166        asynchronous HTTP request, please define a `callback` function
2167        to be invoked when receiving the response.
2168        >>> def callback_function(response):
2169        >>>     pprint(response)
2170        >>>
2171        >>> thread = api.list_signatures_with_http_info(account_id, user_id, callback=callback_function)
2172
2173        :param callback function: The callback function
2174            for asynchronous request. (optional)
2175        :param str account_id: The external account number (int) or account ID Guid. (required)
2176        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2177        :param str stamp_type:
2178        :return: UserSignaturesInformation
2179                 If the method is called asynchronously,
2180                 returns the request thread.
2181        """
2182
2183        all_params = ['account_id', 'user_id', 'stamp_type']
2184        all_params.append('callback')
2185        all_params.append('_return_http_data_only')
2186        all_params.append('_preload_content')
2187        all_params.append('_request_timeout')
2188
2189        params = locals()
2190        for key, val in iteritems(params['kwargs']):
2191            if key not in all_params:
2192                raise TypeError(
2193                    "Got an unexpected keyword argument '%s'"
2194                    " to method list_signatures" % key
2195                )
2196            params[key] = val
2197        del params['kwargs']
2198        # verify the required parameter 'account_id' is set
2199        if ('account_id' not in params) or (params['account_id'] is None):
2200            raise ValueError("Missing the required parameter `account_id` when calling `list_signatures`")
2201        # verify the required parameter 'user_id' is set
2202        if ('user_id' not in params) or (params['user_id'] is None):
2203            raise ValueError("Missing the required parameter `user_id` when calling `list_signatures`")
2204
2205
2206        collection_formats = {}
2207
2208        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures'.replace('{format}', 'json')
2209        path_params = {}
2210        if 'account_id' in params:
2211            path_params['accountId'] = params['account_id']
2212        if 'user_id' in params:
2213            path_params['userId'] = params['user_id']
2214
2215        query_params = {}
2216        if 'stamp_type' in params:
2217            query_params['stamp_type'] = params['stamp_type']
2218
2219        header_params = {}
2220
2221        form_params = []
2222        local_var_files = {}
2223
2224        body_params = None
2225        # HTTP header `Accept`
2226        header_params['Accept'] = self.api_client.\
2227            select_header_accept(['application/json'])
2228
2229        # Authentication setting
2230        auth_settings = []
2231
2232        return self.api_client.call_api(resource_path, 'GET',
2233                                        path_params,
2234                                        query_params,
2235                                        header_params,
2236                                        body=body_params,
2237                                        post_params=form_params,
2238                                        files=local_var_files,
2239                                        response_type='UserSignaturesInformation',
2240                                        auth_settings=auth_settings,
2241                                        callback=params.get('callback'),
2242                                        _return_http_data_only=params.get('_return_http_data_only'),
2243                                        _preload_content=params.get('_preload_content', True),
2244                                        _request_timeout=params.get('_request_timeout'),
2245                                        collection_formats=collection_formats)
2246
2247    def post_contacts(self, account_id, **kwargs):
2248        """
2249        Imports multiple new contacts into the contacts collection from CSV, JSON, or XML (based on content type).
2250        This method adds multiple contacts into a contacts list.
2251        This method makes a synchronous HTTP request by default. To make an
2252        asynchronous HTTP request, please define a `callback` function
2253        to be invoked when receiving the response.
2254        >>> def callback_function(response):
2255        >>>     pprint(response)
2256        >>>
2257        >>> thread = api.post_contacts(account_id, callback=callback_function)
2258
2259        :param callback function: The callback function
2260            for asynchronous request. (optional)
2261        :param str account_id: The external account number (int) or account ID Guid. (required)
2262        :param ContactModRequest contact_mod_request:
2263        :return: ContactUpdateResponse
2264                 If the method is called asynchronously,
2265                 returns the request thread.
2266        """
2267        kwargs['_return_http_data_only'] = True
2268        if kwargs.get('callback'):
2269            return self.post_contacts_with_http_info(account_id, **kwargs)
2270        else:
2271            (data) = self.post_contacts_with_http_info(account_id, **kwargs)
2272            return data
2273
2274    def post_contacts_with_http_info(self, account_id, **kwargs):
2275        """
2276        Imports multiple new contacts into the contacts collection from CSV, JSON, or XML (based on content type).
2277        This method adds multiple contacts into a contacts list.
2278        This method makes a synchronous HTTP request by default. To make an
2279        asynchronous HTTP request, please define a `callback` function
2280        to be invoked when receiving the response.
2281        >>> def callback_function(response):
2282        >>>     pprint(response)
2283        >>>
2284        >>> thread = api.post_contacts_with_http_info(account_id, callback=callback_function)
2285
2286        :param callback function: The callback function
2287            for asynchronous request. (optional)
2288        :param str account_id: The external account number (int) or account ID Guid. (required)
2289        :param ContactModRequest contact_mod_request:
2290        :return: ContactUpdateResponse
2291                 If the method is called asynchronously,
2292                 returns the request thread.
2293        """
2294
2295        all_params = ['account_id', 'contact_mod_request']
2296        all_params.append('callback')
2297        all_params.append('_return_http_data_only')
2298        all_params.append('_preload_content')
2299        all_params.append('_request_timeout')
2300
2301        params = locals()
2302        for key, val in iteritems(params['kwargs']):
2303            if key not in all_params:
2304                raise TypeError(
2305                    "Got an unexpected keyword argument '%s'"
2306                    " to method post_contacts" % key
2307                )
2308            params[key] = val
2309        del params['kwargs']
2310        # verify the required parameter 'account_id' is set
2311        if ('account_id' not in params) or (params['account_id'] is None):
2312            raise ValueError("Missing the required parameter `account_id` when calling `post_contacts`")
2313
2314
2315        collection_formats = {}
2316
2317        resource_path = '/v2.1/accounts/{accountId}/contacts'.replace('{format}', 'json')
2318        path_params = {}
2319        if 'account_id' in params:
2320            path_params['accountId'] = params['account_id']
2321
2322        query_params = {}
2323
2324        header_params = {}
2325
2326        form_params = []
2327        local_var_files = {}
2328
2329        body_params = None
2330        if 'contact_mod_request' in params:
2331            body_params = params['contact_mod_request']
2332        # HTTP header `Accept`
2333        header_params['Accept'] = self.api_client.\
2334            select_header_accept(['application/json'])
2335
2336        # Authentication setting
2337        auth_settings = []
2338
2339        return self.api_client.call_api(resource_path, 'POST',
2340                                        path_params,
2341                                        query_params,
2342                                        header_params,
2343                                        body=body_params,
2344                                        post_params=form_params,
2345                                        files=local_var_files,
2346                                        response_type='ContactUpdateResponse',
2347                                        auth_settings=auth_settings,
2348                                        callback=params.get('callback'),
2349                                        _return_http_data_only=params.get('_return_http_data_only'),
2350                                        _preload_content=params.get('_preload_content', True),
2351                                        _request_timeout=params.get('_request_timeout'),
2352                                        collection_formats=collection_formats)
2353
2354    def put_contacts(self, account_id, **kwargs):
2355        """
2356        Replaces contacts associated with an account for the DocuSign service.
2357        This method updates one or more contacts associated with an account.
2358        This method makes a synchronous HTTP request by default. To make an
2359        asynchronous HTTP request, please define a `callback` function
2360        to be invoked when receiving the response.
2361        >>> def callback_function(response):
2362        >>>     pprint(response)
2363        >>>
2364        >>> thread = api.put_contacts(account_id, callback=callback_function)
2365
2366        :param callback function: The callback function
2367            for asynchronous request. (optional)
2368        :param str account_id: The external account number (int) or account ID Guid. (required)
2369        :param ContactModRequest contact_mod_request:
2370        :return: ContactUpdateResponse
2371                 If the method is called asynchronously,
2372                 returns the request thread.
2373        """
2374        kwargs['_return_http_data_only'] = True
2375        if kwargs.get('callback'):
2376            return self.put_contacts_with_http_info(account_id, **kwargs)
2377        else:
2378            (data) = self.put_contacts_with_http_info(account_id, **kwargs)
2379            return data
2380
2381    def put_contacts_with_http_info(self, account_id, **kwargs):
2382        """
2383        Replaces contacts associated with an account for the DocuSign service.
2384        This method updates one or more contacts associated with an account.
2385        This method makes a synchronous HTTP request by default. To make an
2386        asynchronous HTTP request, please define a `callback` function
2387        to be invoked when receiving the response.
2388        >>> def callback_function(response):
2389        >>>     pprint(response)
2390        >>>
2391        >>> thread = api.put_contacts_with_http_info(account_id, callback=callback_function)
2392
2393        :param callback function: The callback function
2394            for asynchronous request. (optional)
2395        :param str account_id: The external account number (int) or account ID Guid. (required)
2396        :param ContactModRequest contact_mod_request:
2397        :return: ContactUpdateResponse
2398                 If the method is called asynchronously,
2399                 returns the request thread.
2400        """
2401
2402        all_params = ['account_id', 'contact_mod_request']
2403        all_params.append('callback')
2404        all_params.append('_return_http_data_only')
2405        all_params.append('_preload_content')
2406        all_params.append('_request_timeout')
2407
2408        params = locals()
2409        for key, val in iteritems(params['kwargs']):
2410            if key not in all_params:
2411                raise TypeError(
2412                    "Got an unexpected keyword argument '%s'"
2413                    " to method put_contacts" % key
2414                )
2415            params[key] = val
2416        del params['kwargs']
2417        # verify the required parameter 'account_id' is set
2418        if ('account_id' not in params) or (params['account_id'] is None):
2419            raise ValueError("Missing the required parameter `account_id` when calling `put_contacts`")
2420
2421
2422        collection_formats = {}
2423
2424        resource_path = '/v2.1/accounts/{accountId}/contacts'.replace('{format}', 'json')
2425        path_params = {}
2426        if 'account_id' in params:
2427            path_params['accountId'] = params['account_id']
2428
2429        query_params = {}
2430
2431        header_params = {}
2432
2433        form_params = []
2434        local_var_files = {}
2435
2436        body_params = None
2437        if 'contact_mod_request' in params:
2438            body_params = params['contact_mod_request']
2439        # HTTP header `Accept`
2440        header_params['Accept'] = self.api_client.\
2441            select_header_accept(['application/json'])
2442
2443        # Authentication setting
2444        auth_settings = []
2445
2446        return self.api_client.call_api(resource_path, 'PUT',
2447                                        path_params,
2448                                        query_params,
2449                                        header_params,
2450                                        body=body_params,
2451                                        post_params=form_params,
2452                                        files=local_var_files,
2453                                        response_type='ContactUpdateResponse',
2454                                        auth_settings=auth_settings,
2455                                        callback=params.get('callback'),
2456                                        _return_http_data_only=params.get('_return_http_data_only'),
2457                                        _preload_content=params.get('_preload_content', True),
2458                                        _request_timeout=params.get('_request_timeout'),
2459                                        collection_formats=collection_formats)
2460
2461    def update_custom_settings(self, account_id, user_id, **kwargs):
2462        """
2463        Adds or updates custom user settings for the specified user.
2464        Adds or updates custom user settings for the specified user.  ###### Note: Custom user settings are not the same as user account settings.  Custom settings provide a flexible way to store and retrieve custom user information that you can use in your own system.  **Important**: There is a limit on the size for all the custom user settings for a single user. The limit is 4,000 characters, which includes the XML and JSON structure for the settings.  ### Grouping Custom User Settings ###  You can group custom user settings when adding them. Grouping allows you to retrieve settings that are in a specific group, instead of retrieving all the user custom settings.  To group custom user settings, add the following information in the header, after Content-Type:  `X-DocuSign-User-Settings-Key:group_name`  Where the `group_name` is your designated name for the group of customer user settings. Grouping is shown in the Example Request Body below.  When getting or deleting grouped custom user settings, you must include the extra header information.  Grouping custom user settings is not required and if the extra header information is not included, the custom user settings are added normally and can be retrieved or deleted without including the additional header.
2465        This method makes a synchronous HTTP request by default. To make an
2466        asynchronous HTTP request, please define a `callback` function
2467        to be invoked when receiving the response.
2468        >>> def callback_function(response):
2469        >>>     pprint(response)
2470        >>>
2471        >>> thread = api.update_custom_settings(account_id, user_id, callback=callback_function)
2472
2473        :param callback function: The callback function
2474            for asynchronous request. (optional)
2475        :param str account_id: The external account number (int) or account ID Guid. (required)
2476        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2477        :param CustomSettingsInformation custom_settings_information:
2478        :return: CustomSettingsInformation
2479                 If the method is called asynchronously,
2480                 returns the request thread.
2481        """
2482        kwargs['_return_http_data_only'] = True
2483        if kwargs.get('callback'):
2484            return self.update_custom_settings_with_http_info(account_id, user_id, **kwargs)
2485        else:
2486            (data) = self.update_custom_settings_with_http_info(account_id, user_id, **kwargs)
2487            return data
2488
2489    def update_custom_settings_with_http_info(self, account_id, user_id, **kwargs):
2490        """
2491        Adds or updates custom user settings for the specified user.
2492        Adds or updates custom user settings for the specified user.  ###### Note: Custom user settings are not the same as user account settings.  Custom settings provide a flexible way to store and retrieve custom user information that you can use in your own system.  **Important**: There is a limit on the size for all the custom user settings for a single user. The limit is 4,000 characters, which includes the XML and JSON structure for the settings.  ### Grouping Custom User Settings ###  You can group custom user settings when adding them. Grouping allows you to retrieve settings that are in a specific group, instead of retrieving all the user custom settings.  To group custom user settings, add the following information in the header, after Content-Type:  `X-DocuSign-User-Settings-Key:group_name`  Where the `group_name` is your designated name for the group of customer user settings. Grouping is shown in the Example Request Body below.  When getting or deleting grouped custom user settings, you must include the extra header information.  Grouping custom user settings is not required and if the extra header information is not included, the custom user settings are added normally and can be retrieved or deleted without including the additional header.
2493        This method makes a synchronous HTTP request by default. To make an
2494        asynchronous HTTP request, please define a `callback` function
2495        to be invoked when receiving the response.
2496        >>> def callback_function(response):
2497        >>>     pprint(response)
2498        >>>
2499        >>> thread = api.update_custom_settings_with_http_info(account_id, user_id, callback=callback_function)
2500
2501        :param callback function: The callback function
2502            for asynchronous request. (optional)
2503        :param str account_id: The external account number (int) or account ID Guid. (required)
2504        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2505        :param CustomSettingsInformation custom_settings_information:
2506        :return: CustomSettingsInformation
2507                 If the method is called asynchronously,
2508                 returns the request thread.
2509        """
2510
2511        all_params = ['account_id', 'user_id', 'custom_settings_information']
2512        all_params.append('callback')
2513        all_params.append('_return_http_data_only')
2514        all_params.append('_preload_content')
2515        all_params.append('_request_timeout')
2516
2517        params = locals()
2518        for key, val in iteritems(params['kwargs']):
2519            if key not in all_params:
2520                raise TypeError(
2521                    "Got an unexpected keyword argument '%s'"
2522                    " to method update_custom_settings" % key
2523                )
2524            params[key] = val
2525        del params['kwargs']
2526        # verify the required parameter 'account_id' is set
2527        if ('account_id' not in params) or (params['account_id'] is None):
2528            raise ValueError("Missing the required parameter `account_id` when calling `update_custom_settings`")
2529        # verify the required parameter 'user_id' is set
2530        if ('user_id' not in params) or (params['user_id'] is None):
2531            raise ValueError("Missing the required parameter `user_id` when calling `update_custom_settings`")
2532
2533
2534        collection_formats = {}
2535
2536        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/custom_settings'.replace('{format}', 'json')
2537        path_params = {}
2538        if 'account_id' in params:
2539            path_params['accountId'] = params['account_id']
2540        if 'user_id' in params:
2541            path_params['userId'] = params['user_id']
2542
2543        query_params = {}
2544
2545        header_params = {}
2546
2547        form_params = []
2548        local_var_files = {}
2549
2550        body_params = None
2551        if 'custom_settings_information' in params:
2552            body_params = params['custom_settings_information']
2553        # HTTP header `Accept`
2554        header_params['Accept'] = self.api_client.\
2555            select_header_accept(['application/json'])
2556
2557        # Authentication setting
2558        auth_settings = []
2559
2560        return self.api_client.call_api(resource_path, 'PUT',
2561                                        path_params,
2562                                        query_params,
2563                                        header_params,
2564                                        body=body_params,
2565                                        post_params=form_params,
2566                                        files=local_var_files,
2567                                        response_type='CustomSettingsInformation',
2568                                        auth_settings=auth_settings,
2569                                        callback=params.get('callback'),
2570                                        _return_http_data_only=params.get('_return_http_data_only'),
2571                                        _preload_content=params.get('_preload_content', True),
2572                                        _request_timeout=params.get('_request_timeout'),
2573                                        collection_formats=collection_formats)
2574
2575    def update_profile(self, account_id, user_id, **kwargs):
2576        """
2577        Updates the user profile information for the specified user.
2578        Updates the user's detail information, profile information, privacy settings, and personal information in the user ID card.  You can also change a user's name by changing the information in the `userDetails` property. When changing a user's name, you can either change the information in the `userName` property OR change the information in `firstName`, `middleName`, `lastName, suffixName`, and `title` properties. Changes to `firstName`, `middleName`, `lastName`, `suffixName`, and `title` properties take precedence over changes to the `userName` property.
2579        This method makes a synchronous HTTP request by default. To make an
2580        asynchronous HTTP request, please define a `callback` function
2581        to be invoked when receiving the response.
2582        >>> def callback_function(response):
2583        >>>     pprint(response)
2584        >>>
2585        >>> thread = api.update_profile(account_id, user_id, callback=callback_function)
2586
2587        :param callback function: The callback function
2588            for asynchronous request. (optional)
2589        :param str account_id: The external account number (int) or account ID Guid. (required)
2590        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2591        :param UserProfile user_profile:
2592        :return: None
2593                 If the method is called asynchronously,
2594                 returns the request thread.
2595        """
2596        kwargs['_return_http_data_only'] = True
2597        if kwargs.get('callback'):
2598            return self.update_profile_with_http_info(account_id, user_id, **kwargs)
2599        else:
2600            (data) = self.update_profile_with_http_info(account_id, user_id, **kwargs)
2601            return data
2602
2603    def update_profile_with_http_info(self, account_id, user_id, **kwargs):
2604        """
2605        Updates the user profile information for the specified user.
2606        Updates the user's detail information, profile information, privacy settings, and personal information in the user ID card.  You can also change a user's name by changing the information in the `userDetails` property. When changing a user's name, you can either change the information in the `userName` property OR change the information in `firstName`, `middleName`, `lastName, suffixName`, and `title` properties. Changes to `firstName`, `middleName`, `lastName`, `suffixName`, and `title` properties take precedence over changes to the `userName` property.
2607        This method makes a synchronous HTTP request by default. To make an
2608        asynchronous HTTP request, please define a `callback` function
2609        to be invoked when receiving the response.
2610        >>> def callback_function(response):
2611        >>>     pprint(response)
2612        >>>
2613        >>> thread = api.update_profile_with_http_info(account_id, user_id, callback=callback_function)
2614
2615        :param callback function: The callback function
2616            for asynchronous request. (optional)
2617        :param str account_id: The external account number (int) or account ID Guid. (required)
2618        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2619        :param UserProfile user_profile:
2620        :return: None
2621                 If the method is called asynchronously,
2622                 returns the request thread.
2623        """
2624
2625        all_params = ['account_id', 'user_id', 'user_profile']
2626        all_params.append('callback')
2627        all_params.append('_return_http_data_only')
2628        all_params.append('_preload_content')
2629        all_params.append('_request_timeout')
2630
2631        params = locals()
2632        for key, val in iteritems(params['kwargs']):
2633            if key not in all_params:
2634                raise TypeError(
2635                    "Got an unexpected keyword argument '%s'"
2636                    " to method update_profile" % key
2637                )
2638            params[key] = val
2639        del params['kwargs']
2640        # verify the required parameter 'account_id' is set
2641        if ('account_id' not in params) or (params['account_id'] is None):
2642            raise ValueError("Missing the required parameter `account_id` when calling `update_profile`")
2643        # verify the required parameter 'user_id' is set
2644        if ('user_id' not in params) or (params['user_id'] is None):
2645            raise ValueError("Missing the required parameter `user_id` when calling `update_profile`")
2646
2647
2648        collection_formats = {}
2649
2650        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/profile'.replace('{format}', 'json')
2651        path_params = {}
2652        if 'account_id' in params:
2653            path_params['accountId'] = params['account_id']
2654        if 'user_id' in params:
2655            path_params['userId'] = params['user_id']
2656
2657        query_params = {}
2658
2659        header_params = {}
2660
2661        form_params = []
2662        local_var_files = {}
2663
2664        body_params = None
2665        if 'user_profile' in params:
2666            body_params = params['user_profile']
2667        # HTTP header `Accept`
2668        header_params['Accept'] = self.api_client.\
2669            select_header_accept(['application/json'])
2670
2671        # Authentication setting
2672        auth_settings = []
2673
2674        return self.api_client.call_api(resource_path, 'PUT',
2675                                        path_params,
2676                                        query_params,
2677                                        header_params,
2678                                        body=body_params,
2679                                        post_params=form_params,
2680                                        files=local_var_files,
2681                                        response_type=None,
2682                                        auth_settings=auth_settings,
2683                                        callback=params.get('callback'),
2684                                        _return_http_data_only=params.get('_return_http_data_only'),
2685                                        _preload_content=params.get('_preload_content', True),
2686                                        _request_timeout=params.get('_request_timeout'),
2687                                        collection_formats=collection_formats)
2688
2689    def update_profile_image(self, account_id, user_id, **kwargs):
2690        """
2691        Updates the user profile image for a specified user.
2692        Updates the user profile image by uploading an image to the user profile.  The supported image formats are: gif, png, jpeg, and bmp. The file must be less than 200K. For best viewing results, DocuSign recommends that the image is no more than 79 pixels wide and high.
2693        This method makes a synchronous HTTP request by default. To make an
2694        asynchronous HTTP request, please define a `callback` function
2695        to be invoked when receiving the response.
2696        >>> def callback_function(response):
2697        >>>     pprint(response)
2698        >>>
2699        >>> thread = api.update_profile_image(account_id, user_id, callback=callback_function)
2700
2701        :param callback function: The callback function
2702            for asynchronous request. (optional)
2703        :param str account_id: The external account number (int) or account ID Guid. (required)
2704        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2705        :return: None
2706                 If the method is called asynchronously,
2707                 returns the request thread.
2708        """
2709        kwargs['_return_http_data_only'] = True
2710        if kwargs.get('callback'):
2711            return self.update_profile_image_with_http_info(account_id, user_id, **kwargs)
2712        else:
2713            (data) = self.update_profile_image_with_http_info(account_id, user_id, **kwargs)
2714            return data
2715
2716    def update_profile_image_with_http_info(self, account_id, user_id, **kwargs):
2717        """
2718        Updates the user profile image for a specified user.
2719        Updates the user profile image by uploading an image to the user profile.  The supported image formats are: gif, png, jpeg, and bmp. The file must be less than 200K. For best viewing results, DocuSign recommends that the image is no more than 79 pixels wide and high.
2720        This method makes a synchronous HTTP request by default. To make an
2721        asynchronous HTTP request, please define a `callback` function
2722        to be invoked when receiving the response.
2723        >>> def callback_function(response):
2724        >>>     pprint(response)
2725        >>>
2726        >>> thread = api.update_profile_image_with_http_info(account_id, user_id, callback=callback_function)
2727
2728        :param callback function: The callback function
2729            for asynchronous request. (optional)
2730        :param str account_id: The external account number (int) or account ID Guid. (required)
2731        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2732        :return: None
2733                 If the method is called asynchronously,
2734                 returns the request thread.
2735        """
2736
2737        all_params = ['account_id', 'user_id']
2738        all_params.append('callback')
2739        all_params.append('_return_http_data_only')
2740        all_params.append('_preload_content')
2741        all_params.append('_request_timeout')
2742
2743        params = locals()
2744        for key, val in iteritems(params['kwargs']):
2745            if key not in all_params:
2746                raise TypeError(
2747                    "Got an unexpected keyword argument '%s'"
2748                    " to method update_profile_image" % key
2749                )
2750            params[key] = val
2751        del params['kwargs']
2752        # verify the required parameter 'account_id' is set
2753        if ('account_id' not in params) or (params['account_id'] is None):
2754            raise ValueError("Missing the required parameter `account_id` when calling `update_profile_image`")
2755        # verify the required parameter 'user_id' is set
2756        if ('user_id' not in params) or (params['user_id'] is None):
2757            raise ValueError("Missing the required parameter `user_id` when calling `update_profile_image`")
2758
2759
2760        collection_formats = {}
2761
2762        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/profile/image'.replace('{format}', 'json')
2763        path_params = {}
2764        if 'account_id' in params:
2765            path_params['accountId'] = params['account_id']
2766        if 'user_id' in params:
2767            path_params['userId'] = params['user_id']
2768
2769        query_params = {}
2770
2771        header_params = {}
2772
2773        form_params = []
2774        local_var_files = {}
2775
2776        body_params = None
2777        # HTTP header `Accept`
2778        header_params['Accept'] = self.api_client.\
2779            select_header_accept(['application/json'])
2780
2781        # HTTP header `Content-Type`
2782        header_params['Content-Type'] = self.api_client.\
2783            select_header_content_type(['image/gif'])
2784
2785        # Authentication setting
2786        auth_settings = []
2787
2788        return self.api_client.call_api(resource_path, 'PUT',
2789                                        path_params,
2790                                        query_params,
2791                                        header_params,
2792                                        body=body_params,
2793                                        post_params=form_params,
2794                                        files=local_var_files,
2795                                        response_type=None,
2796                                        auth_settings=auth_settings,
2797                                        callback=params.get('callback'),
2798                                        _return_http_data_only=params.get('_return_http_data_only'),
2799                                        _preload_content=params.get('_preload_content', True),
2800                                        _request_timeout=params.get('_request_timeout'),
2801                                        collection_formats=collection_formats)
2802
2803    def update_settings(self, account_id, user_id, **kwargs):
2804        """
2805        Updates the user account settings for a specified user.
2806        Updates the account settings list and email notification types for the specified user.
2807        This method makes a synchronous HTTP request by default. To make an
2808        asynchronous HTTP request, please define a `callback` function
2809        to be invoked when receiving the response.
2810        >>> def callback_function(response):
2811        >>>     pprint(response)
2812        >>>
2813        >>> thread = api.update_settings(account_id, user_id, callback=callback_function)
2814
2815        :param callback function: The callback function
2816            for asynchronous request. (optional)
2817        :param str account_id: The external account number (int) or account ID Guid. (required)
2818        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2819        :param str allow_all_languages:
2820        :param UserSettingsInformation user_settings_information:
2821        :return: None
2822                 If the method is called asynchronously,
2823                 returns the request thread.
2824        """
2825        kwargs['_return_http_data_only'] = True
2826        if kwargs.get('callback'):
2827            return self.update_settings_with_http_info(account_id, user_id, **kwargs)
2828        else:
2829            (data) = self.update_settings_with_http_info(account_id, user_id, **kwargs)
2830            return data
2831
2832    def update_settings_with_http_info(self, account_id, user_id, **kwargs):
2833        """
2834        Updates the user account settings for a specified user.
2835        Updates the account settings list and email notification types for the specified user.
2836        This method makes a synchronous HTTP request by default. To make an
2837        asynchronous HTTP request, please define a `callback` function
2838        to be invoked when receiving the response.
2839        >>> def callback_function(response):
2840        >>>     pprint(response)
2841        >>>
2842        >>> thread = api.update_settings_with_http_info(account_id, user_id, callback=callback_function)
2843
2844        :param callback function: The callback function
2845            for asynchronous request. (optional)
2846        :param str account_id: The external account number (int) or account ID Guid. (required)
2847        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2848        :param str allow_all_languages:
2849        :param UserSettingsInformation user_settings_information:
2850        :return: None
2851                 If the method is called asynchronously,
2852                 returns the request thread.
2853        """
2854
2855        all_params = ['account_id', 'user_id', 'allow_all_languages', 'user_settings_information']
2856        all_params.append('callback')
2857        all_params.append('_return_http_data_only')
2858        all_params.append('_preload_content')
2859        all_params.append('_request_timeout')
2860
2861        params = locals()
2862        for key, val in iteritems(params['kwargs']):
2863            if key not in all_params:
2864                raise TypeError(
2865                    "Got an unexpected keyword argument '%s'"
2866                    " to method update_settings" % key
2867                )
2868            params[key] = val
2869        del params['kwargs']
2870        # verify the required parameter 'account_id' is set
2871        if ('account_id' not in params) or (params['account_id'] is None):
2872            raise ValueError("Missing the required parameter `account_id` when calling `update_settings`")
2873        # verify the required parameter 'user_id' is set
2874        if ('user_id' not in params) or (params['user_id'] is None):
2875            raise ValueError("Missing the required parameter `user_id` when calling `update_settings`")
2876
2877
2878        collection_formats = {}
2879
2880        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/settings'.replace('{format}', 'json')
2881        path_params = {}
2882        if 'account_id' in params:
2883            path_params['accountId'] = params['account_id']
2884        if 'user_id' in params:
2885            path_params['userId'] = params['user_id']
2886
2887        query_params = {}
2888        if 'allow_all_languages' in params:
2889            query_params['allow_all_languages'] = params['allow_all_languages']
2890
2891        header_params = {}
2892
2893        form_params = []
2894        local_var_files = {}
2895
2896        body_params = None
2897        if 'user_settings_information' in params:
2898            body_params = params['user_settings_information']
2899        # HTTP header `Accept`
2900        header_params['Accept'] = self.api_client.\
2901            select_header_accept(['application/json'])
2902
2903        # Authentication setting
2904        auth_settings = []
2905
2906        return self.api_client.call_api(resource_path, 'PUT',
2907                                        path_params,
2908                                        query_params,
2909                                        header_params,
2910                                        body=body_params,
2911                                        post_params=form_params,
2912                                        files=local_var_files,
2913                                        response_type=None,
2914                                        auth_settings=auth_settings,
2915                                        callback=params.get('callback'),
2916                                        _return_http_data_only=params.get('_return_http_data_only'),
2917                                        _preload_content=params.get('_preload_content', True),
2918                                        _request_timeout=params.get('_request_timeout'),
2919                                        collection_formats=collection_formats)
2920
2921    def update_signature(self, account_id, signature_id, user_id, **kwargs):
2922        """
2923        Updates the user signature for a specified user.
2924        Creates, or updates, the signature font and initials for the specified user. When creating a signature, you use this resource to create the signature name and then add the signature and initials images into the signature.  ###### Note: This will also create a default signature for the user when one does not exist.  The userId property specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
2925        This method makes a synchronous HTTP request by default. To make an
2926        asynchronous HTTP request, please define a `callback` function
2927        to be invoked when receiving the response.
2928        >>> def callback_function(response):
2929        >>>     pprint(response)
2930        >>>
2931        >>> thread = api.update_signature(account_id, signature_id, user_id, callback=callback_function)
2932
2933        :param callback function: The callback function
2934            for asynchronous request. (optional)
2935        :param str account_id: The external account number (int) or account ID Guid. (required)
2936        :param str signature_id: The ID of the signature being accessed. (required)
2937        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2938        :param str close_existing_signature: When set to **true**, closes the current signature.
2939        :param UserSignatureDefinition user_signature_definition:
2940        :return: UserSignature
2941                 If the method is called asynchronously,
2942                 returns the request thread.
2943        """
2944        kwargs['_return_http_data_only'] = True
2945        if kwargs.get('callback'):
2946            return self.update_signature_with_http_info(account_id, signature_id, user_id, **kwargs)
2947        else:
2948            (data) = self.update_signature_with_http_info(account_id, signature_id, user_id, **kwargs)
2949            return data
2950
2951    def update_signature_with_http_info(self, account_id, signature_id, user_id, **kwargs):
2952        """
2953        Updates the user signature for a specified user.
2954        Creates, or updates, the signature font and initials for the specified user. When creating a signature, you use this resource to create the signature name and then add the signature and initials images into the signature.  ###### Note: This will also create a default signature for the user when one does not exist.  The userId property specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\".
2955        This method makes a synchronous HTTP request by default. To make an
2956        asynchronous HTTP request, please define a `callback` function
2957        to be invoked when receiving the response.
2958        >>> def callback_function(response):
2959        >>>     pprint(response)
2960        >>>
2961        >>> thread = api.update_signature_with_http_info(account_id, signature_id, user_id, callback=callback_function)
2962
2963        :param callback function: The callback function
2964            for asynchronous request. (optional)
2965        :param str account_id: The external account number (int) or account ID Guid. (required)
2966        :param str signature_id: The ID of the signature being accessed. (required)
2967        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
2968        :param str close_existing_signature: When set to **true**, closes the current signature.
2969        :param UserSignatureDefinition user_signature_definition:
2970        :return: UserSignature
2971                 If the method is called asynchronously,
2972                 returns the request thread.
2973        """
2974
2975        all_params = ['account_id', 'signature_id', 'user_id', 'close_existing_signature', 'user_signature_definition']
2976        all_params.append('callback')
2977        all_params.append('_return_http_data_only')
2978        all_params.append('_preload_content')
2979        all_params.append('_request_timeout')
2980
2981        params = locals()
2982        for key, val in iteritems(params['kwargs']):
2983            if key not in all_params:
2984                raise TypeError(
2985                    "Got an unexpected keyword argument '%s'"
2986                    " to method update_signature" % key
2987                )
2988            params[key] = val
2989        del params['kwargs']
2990        # verify the required parameter 'account_id' is set
2991        if ('account_id' not in params) or (params['account_id'] is None):
2992            raise ValueError("Missing the required parameter `account_id` when calling `update_signature`")
2993        # verify the required parameter 'signature_id' is set
2994        if ('signature_id' not in params) or (params['signature_id'] is None):
2995            raise ValueError("Missing the required parameter `signature_id` when calling `update_signature`")
2996        # verify the required parameter 'user_id' is set
2997        if ('user_id' not in params) or (params['user_id'] is None):
2998            raise ValueError("Missing the required parameter `user_id` when calling `update_signature`")
2999
3000
3001        collection_formats = {}
3002
3003        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures/{signatureId}'.replace('{format}', 'json')
3004        path_params = {}
3005        if 'account_id' in params:
3006            path_params['accountId'] = params['account_id']
3007        if 'signature_id' in params:
3008            path_params['signatureId'] = params['signature_id']
3009        if 'user_id' in params:
3010            path_params['userId'] = params['user_id']
3011
3012        query_params = {}
3013        if 'close_existing_signature' in params:
3014            query_params['close_existing_signature'] = params['close_existing_signature']
3015
3016        header_params = {}
3017
3018        form_params = []
3019        local_var_files = {}
3020
3021        body_params = None
3022        if 'user_signature_definition' in params:
3023            body_params = params['user_signature_definition']
3024        # HTTP header `Accept`
3025        header_params['Accept'] = self.api_client.\
3026            select_header_accept(['application/json'])
3027
3028        # Authentication setting
3029        auth_settings = []
3030
3031        return self.api_client.call_api(resource_path, 'PUT',
3032                                        path_params,
3033                                        query_params,
3034                                        header_params,
3035                                        body=body_params,
3036                                        post_params=form_params,
3037                                        files=local_var_files,
3038                                        response_type='UserSignature',
3039                                        auth_settings=auth_settings,
3040                                        callback=params.get('callback'),
3041                                        _return_http_data_only=params.get('_return_http_data_only'),
3042                                        _preload_content=params.get('_preload_content', True),
3043                                        _request_timeout=params.get('_request_timeout'),
3044                                        collection_formats=collection_formats)
3045
3046    def update_signature_image(self, account_id, image_type, signature_id, user_id, **kwargs):
3047        """
3048        Updates the user signature image or user initials image for the specified user.
3049        Updates the user signature image or user initials image for the specified user. The supported image formats for this file are: gif, png, jpeg, and bmp. The file must be less than 200K.  The userId property specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\". 
3050        This method makes a synchronous HTTP request by default. To make an
3051        asynchronous HTTP request, please define a `callback` function
3052        to be invoked when receiving the response.
3053        >>> def callback_function(response):
3054        >>>     pprint(response)
3055        >>>
3056        >>> thread = api.update_signature_image(account_id, image_type, signature_id, user_id, callback=callback_function)
3057
3058        :param callback function: The callback function
3059            for asynchronous request. (optional)
3060        :param str account_id: The external account number (int) or account ID Guid. (required)
3061        :param str image_type: One of **signature_image** or **initials_image**. (required)
3062        :param str signature_id: The ID of the signature being accessed. (required)
3063        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
3064        :param str transparent_png:
3065        :return: UserSignature
3066                 If the method is called asynchronously,
3067                 returns the request thread.
3068        """
3069        kwargs['_return_http_data_only'] = True
3070        if kwargs.get('callback'):
3071            return self.update_signature_image_with_http_info(account_id, image_type, signature_id, user_id, **kwargs)
3072        else:
3073            (data) = self.update_signature_image_with_http_info(account_id, image_type, signature_id, user_id, **kwargs)
3074            return data
3075
3076    def update_signature_image_with_http_info(self, account_id, image_type, signature_id, user_id, **kwargs):
3077        """
3078        Updates the user signature image or user initials image for the specified user.
3079        Updates the user signature image or user initials image for the specified user. The supported image formats for this file are: gif, png, jpeg, and bmp. The file must be less than 200K.  The userId property specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account.  The `signatureId` parameter accepts a signature ID or a signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly encode into a URL. If you use the user name, it is likely that the name includes spaces. In that case, URL encode the name before using it in the endpoint.   For example encode \"Bob Smith\" as \"Bob%20Smith\". 
3080        This method makes a synchronous HTTP request by default. To make an
3081        asynchronous HTTP request, please define a `callback` function
3082        to be invoked when receiving the response.
3083        >>> def callback_function(response):
3084        >>>     pprint(response)
3085        >>>
3086        >>> thread = api.update_signature_image_with_http_info(account_id, image_type, signature_id, user_id, callback=callback_function)
3087
3088        :param callback function: The callback function
3089            for asynchronous request. (optional)
3090        :param str account_id: The external account number (int) or account ID Guid. (required)
3091        :param str image_type: One of **signature_image** or **initials_image**. (required)
3092        :param str signature_id: The ID of the signature being accessed. (required)
3093        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
3094        :param str transparent_png:
3095        :return: UserSignature
3096                 If the method is called asynchronously,
3097                 returns the request thread.
3098        """
3099
3100        all_params = ['account_id', 'image_type', 'signature_id', 'user_id', 'transparent_png']
3101        all_params.append('callback')
3102        all_params.append('_return_http_data_only')
3103        all_params.append('_preload_content')
3104        all_params.append('_request_timeout')
3105
3106        params = locals()
3107        for key, val in iteritems(params['kwargs']):
3108            if key not in all_params:
3109                raise TypeError(
3110                    "Got an unexpected keyword argument '%s'"
3111                    " to method update_signature_image" % key
3112                )
3113            params[key] = val
3114        del params['kwargs']
3115        # verify the required parameter 'account_id' is set
3116        if ('account_id' not in params) or (params['account_id'] is None):
3117            raise ValueError("Missing the required parameter `account_id` when calling `update_signature_image`")
3118        # verify the required parameter 'image_type' is set
3119        if ('image_type' not in params) or (params['image_type'] is None):
3120            raise ValueError("Missing the required parameter `image_type` when calling `update_signature_image`")
3121        # verify the required parameter 'signature_id' is set
3122        if ('signature_id' not in params) or (params['signature_id'] is None):
3123            raise ValueError("Missing the required parameter `signature_id` when calling `update_signature_image`")
3124        # verify the required parameter 'user_id' is set
3125        if ('user_id' not in params) or (params['user_id'] is None):
3126            raise ValueError("Missing the required parameter `user_id` when calling `update_signature_image`")
3127
3128
3129        collection_formats = {}
3130
3131        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
3132        path_params = {}
3133        if 'account_id' in params:
3134            path_params['accountId'] = params['account_id']
3135        if 'image_type' in params:
3136            path_params['imageType'] = params['image_type']
3137        if 'signature_id' in params:
3138            path_params['signatureId'] = params['signature_id']
3139        if 'user_id' in params:
3140            path_params['userId'] = params['user_id']
3141
3142        query_params = {}
3143        if 'transparent_png' in params:
3144            query_params['transparent_png'] = params['transparent_png']
3145
3146        header_params = {}
3147
3148        form_params = []
3149        local_var_files = {}
3150
3151        body_params = None
3152        # HTTP header `Accept`
3153        header_params['Accept'] = self.api_client.\
3154            select_header_accept(['application/json'])
3155
3156        # HTTP header `Content-Type`
3157        header_params['Content-Type'] = self.api_client.\
3158            select_header_content_type(['image/gif'])
3159
3160        # Authentication setting
3161        auth_settings = []
3162
3163        return self.api_client.call_api(resource_path, 'PUT',
3164                                        path_params,
3165                                        query_params,
3166                                        header_params,
3167                                        body=body_params,
3168                                        post_params=form_params,
3169                                        files=local_var_files,
3170                                        response_type='UserSignature',
3171                                        auth_settings=auth_settings,
3172                                        callback=params.get('callback'),
3173                                        _return_http_data_only=params.get('_return_http_data_only'),
3174                                        _preload_content=params.get('_preload_content', True),
3175                                        _request_timeout=params.get('_request_timeout'),
3176                                        collection_formats=collection_formats)
3177
3178    def update_signatures(self, account_id, user_id, **kwargs):
3179        """
3180        Adds/updates a user signature.
3181        
3182        This method makes a synchronous HTTP request by default. To make an
3183        asynchronous HTTP request, please define a `callback` function
3184        to be invoked when receiving the response.
3185        >>> def callback_function(response):
3186        >>>     pprint(response)
3187        >>>
3188        >>> thread = api.update_signatures(account_id, user_id, callback=callback_function)
3189
3190        :param callback function: The callback function
3191            for asynchronous request. (optional)
3192        :param str account_id: The external account number (int) or account ID Guid. (required)
3193        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
3194        :param UserSignaturesInformation user_signatures_information:
3195        :return: UserSignaturesInformation
3196                 If the method is called asynchronously,
3197                 returns the request thread.
3198        """
3199        kwargs['_return_http_data_only'] = True
3200        if kwargs.get('callback'):
3201            return self.update_signatures_with_http_info(account_id, user_id, **kwargs)
3202        else:
3203            (data) = self.update_signatures_with_http_info(account_id, user_id, **kwargs)
3204            return data
3205
3206    def update_signatures_with_http_info(self, account_id, user_id, **kwargs):
3207        """
3208        Adds/updates a user signature.
3209        
3210        This method makes a synchronous HTTP request by default. To make an
3211        asynchronous HTTP request, please define a `callback` function
3212        to be invoked when receiving the response.
3213        >>> def callback_function(response):
3214        >>>     pprint(response)
3215        >>>
3216        >>> thread = api.update_signatures_with_http_info(account_id, user_id, callback=callback_function)
3217
3218        :param callback function: The callback function
3219            for asynchronous request. (optional)
3220        :param str account_id: The external account number (int) or account ID Guid. (required)
3221        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
3222        :param UserSignaturesInformation user_signatures_information:
3223        :return: UserSignaturesInformation
3224                 If the method is called asynchronously,
3225                 returns the request thread.
3226        """
3227
3228        all_params = ['account_id', 'user_id', 'user_signatures_information']
3229        all_params.append('callback')
3230        all_params.append('_return_http_data_only')
3231        all_params.append('_preload_content')
3232        all_params.append('_request_timeout')
3233
3234        params = locals()
3235        for key, val in iteritems(params['kwargs']):
3236            if key not in all_params:
3237                raise TypeError(
3238                    "Got an unexpected keyword argument '%s'"
3239                    " to method update_signatures" % key
3240                )
3241            params[key] = val
3242        del params['kwargs']
3243        # verify the required parameter 'account_id' is set
3244        if ('account_id' not in params) or (params['account_id'] is None):
3245            raise ValueError("Missing the required parameter `account_id` when calling `update_signatures`")
3246        # verify the required parameter 'user_id' is set
3247        if ('user_id' not in params) or (params['user_id'] is None):
3248            raise ValueError("Missing the required parameter `user_id` when calling `update_signatures`")
3249
3250
3251        collection_formats = {}
3252
3253        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/signatures'.replace('{format}', 'json')
3254        path_params = {}
3255        if 'account_id' in params:
3256            path_params['accountId'] = params['account_id']
3257        if 'user_id' in params:
3258            path_params['userId'] = params['user_id']
3259
3260        query_params = {}
3261
3262        header_params = {}
3263
3264        form_params = []
3265        local_var_files = {}
3266
3267        body_params = None
3268        if 'user_signatures_information' in params:
3269            body_params = params['user_signatures_information']
3270        # HTTP header `Accept`
3271        header_params['Accept'] = self.api_client.\
3272            select_header_accept(['application/json'])
3273
3274        # Authentication setting
3275        auth_settings = []
3276
3277        return self.api_client.call_api(resource_path, 'PUT',
3278                                        path_params,
3279                                        query_params,
3280                                        header_params,
3281                                        body=body_params,
3282                                        post_params=form_params,
3283                                        files=local_var_files,
3284                                        response_type='UserSignaturesInformation',
3285                                        auth_settings=auth_settings,
3286                                        callback=params.get('callback'),
3287                                        _return_http_data_only=params.get('_return_http_data_only'),
3288                                        _preload_content=params.get('_preload_content', True),
3289                                        _request_timeout=params.get('_request_timeout'),
3290                                        collection_formats=collection_formats)
3291
3292    def update_user(self, account_id, user_id, **kwargs):
3293        """
3294        Updates the specified user information.
3295        To update user information for a specific user, submit a [Users](#Users) object with updated field values in the request body of this operation.
3296        This method makes a synchronous HTTP request by default. To make an
3297        asynchronous HTTP request, please define a `callback` function
3298        to be invoked when receiving the response.
3299        >>> def callback_function(response):
3300        >>>     pprint(response)
3301        >>>
3302        >>> thread = api.update_user(account_id, user_id, callback=callback_function)
3303
3304        :param callback function: The callback function
3305            for asynchronous request. (optional)
3306        :param str account_id: The external account number (int) or account ID Guid. (required)
3307        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
3308        :param str allow_all_languages:
3309        :param UserInformation user_information:
3310        :return: UserInformation
3311                 If the method is called asynchronously,
3312                 returns the request thread.
3313        """
3314        kwargs['_return_http_data_only'] = True
3315        if kwargs.get('callback'):
3316            return self.update_user_with_http_info(account_id, user_id, **kwargs)
3317        else:
3318            (data) = self.update_user_with_http_info(account_id, user_id, **kwargs)
3319            return data
3320
3321    def update_user_with_http_info(self, account_id, user_id, **kwargs):
3322        """
3323        Updates the specified user information.
3324        To update user information for a specific user, submit a [Users](#Users) object with updated field values in the request body of this operation.
3325        This method makes a synchronous HTTP request by default. To make an
3326        asynchronous HTTP request, please define a `callback` function
3327        to be invoked when receiving the response.
3328        >>> def callback_function(response):
3329        >>>     pprint(response)
3330        >>>
3331        >>> thread = api.update_user_with_http_info(account_id, user_id, callback=callback_function)
3332
3333        :param callback function: The callback function
3334            for asynchronous request. (optional)
3335        :param str account_id: The external account number (int) or account ID Guid. (required)
3336        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
3337        :param str allow_all_languages:
3338        :param UserInformation user_information:
3339        :return: UserInformation
3340                 If the method is called asynchronously,
3341                 returns the request thread.
3342        """
3343
3344        all_params = ['account_id', 'user_id', 'allow_all_languages', 'user_information']
3345        all_params.append('callback')
3346        all_params.append('_return_http_data_only')
3347        all_params.append('_preload_content')
3348        all_params.append('_request_timeout')
3349
3350        params = locals()
3351        for key, val in iteritems(params['kwargs']):
3352            if key not in all_params:
3353                raise TypeError(
3354                    "Got an unexpected keyword argument '%s'"
3355                    " to method update_user" % key
3356                )
3357            params[key] = val
3358        del params['kwargs']
3359        # verify the required parameter 'account_id' is set
3360        if ('account_id' not in params) or (params['account_id'] is None):
3361            raise ValueError("Missing the required parameter `account_id` when calling `update_user`")
3362        # verify the required parameter 'user_id' is set
3363        if ('user_id' not in params) or (params['user_id'] is None):
3364            raise ValueError("Missing the required parameter `user_id` when calling `update_user`")
3365
3366
3367        collection_formats = {}
3368
3369        resource_path = '/v2.1/accounts/{accountId}/users/{userId}'.replace('{format}', 'json')
3370        path_params = {}
3371        if 'account_id' in params:
3372            path_params['accountId'] = params['account_id']
3373        if 'user_id' in params:
3374            path_params['userId'] = params['user_id']
3375
3376        query_params = {}
3377        if 'allow_all_languages' in params:
3378            query_params['allow_all_languages'] = params['allow_all_languages']
3379
3380        header_params = {}
3381
3382        form_params = []
3383        local_var_files = {}
3384
3385        body_params = None
3386        if 'user_information' in params:
3387            body_params = params['user_information']
3388        # HTTP header `Accept`
3389        header_params['Accept'] = self.api_client.\
3390            select_header_accept(['application/json'])
3391
3392        # Authentication setting
3393        auth_settings = []
3394
3395        return self.api_client.call_api(resource_path, 'PUT',
3396                                        path_params,
3397                                        query_params,
3398                                        header_params,
3399                                        body=body_params,
3400                                        post_params=form_params,
3401                                        files=local_var_files,
3402                                        response_type='UserInformation',
3403                                        auth_settings=auth_settings,
3404                                        callback=params.get('callback'),
3405                                        _return_http_data_only=params.get('_return_http_data_only'),
3406                                        _preload_content=params.get('_preload_content', True),
3407                                        _request_timeout=params.get('_request_timeout'),
3408                                        collection_formats=collection_formats)
3409
3410    def update_users(self, account_id, **kwargs):
3411        """
3412        Change one or more user in the specified account.
3413        This method updates the information about one or more account users.
3414        This method makes a synchronous HTTP request by default. To make an
3415        asynchronous HTTP request, please define a `callback` function
3416        to be invoked when receiving the response.
3417        >>> def callback_function(response):
3418        >>>     pprint(response)
3419        >>>
3420        >>> thread = api.update_users(account_id, callback=callback_function)
3421
3422        :param callback function: The callback function
3423            for asynchronous request. (optional)
3424        :param str account_id: The external account number (int) or account ID Guid. (required)
3425        :param str allow_all_languages:
3426        :param UserInformationList user_information_list:
3427        :return: UserInformationList
3428                 If the method is called asynchronously,
3429                 returns the request thread.
3430        """
3431        kwargs['_return_http_data_only'] = True
3432        if kwargs.get('callback'):
3433            return self.update_users_with_http_info(account_id, **kwargs)
3434        else:
3435            (data) = self.update_users_with_http_info(account_id, **kwargs)
3436            return data
3437
3438    def update_users_with_http_info(self, account_id, **kwargs):
3439        """
3440        Change one or more user in the specified account.
3441        This method updates the information about one or more account users.
3442        This method makes a synchronous HTTP request by default. To make an
3443        asynchronous HTTP request, please define a `callback` function
3444        to be invoked when receiving the response.
3445        >>> def callback_function(response):
3446        >>>     pprint(response)
3447        >>>
3448        >>> thread = api.update_users_with_http_info(account_id, callback=callback_function)
3449
3450        :param callback function: The callback function
3451            for asynchronous request. (optional)
3452        :param str account_id: The external account number (int) or account ID Guid. (required)
3453        :param str allow_all_languages:
3454        :param UserInformationList user_information_list:
3455        :return: UserInformationList
3456                 If the method is called asynchronously,
3457                 returns the request thread.
3458        """
3459
3460        all_params = ['account_id', 'allow_all_languages', 'user_information_list']
3461        all_params.append('callback')
3462        all_params.append('_return_http_data_only')
3463        all_params.append('_preload_content')
3464        all_params.append('_request_timeout')
3465
3466        params = locals()
3467        for key, val in iteritems(params['kwargs']):
3468            if key not in all_params:
3469                raise TypeError(
3470                    "Got an unexpected keyword argument '%s'"
3471                    " to method update_users" % key
3472                )
3473            params[key] = val
3474        del params['kwargs']
3475        # verify the required parameter 'account_id' is set
3476        if ('account_id' not in params) or (params['account_id'] is None):
3477            raise ValueError("Missing the required parameter `account_id` when calling `update_users`")
3478
3479
3480        collection_formats = {}
3481
3482        resource_path = '/v2.1/accounts/{accountId}/users'.replace('{format}', 'json')
3483        path_params = {}
3484        if 'account_id' in params:
3485            path_params['accountId'] = params['account_id']
3486
3487        query_params = {}
3488        if 'allow_all_languages' in params:
3489            query_params['allow_all_languages'] = params['allow_all_languages']
3490
3491        header_params = {}
3492
3493        form_params = []
3494        local_var_files = {}
3495
3496        body_params = None
3497        if 'user_information_list' in params:
3498            body_params = params['user_information_list']
3499        # HTTP header `Accept`
3500        header_params['Accept'] = self.api_client.\
3501            select_header_accept(['application/json'])
3502
3503        # Authentication setting
3504        auth_settings = []
3505
3506        return self.api_client.call_api(resource_path, 'PUT',
3507                                        path_params,
3508                                        query_params,
3509                                        header_params,
3510                                        body=body_params,
3511                                        post_params=form_params,
3512                                        files=local_var_files,
3513                                        response_type='UserInformationList',
3514                                        auth_settings=auth_settings,
3515                                        callback=params.get('callback'),
3516                                        _return_http_data_only=params.get('_return_http_data_only'),
3517                                        _preload_content=params.get('_preload_content', True),
3518                                        _request_timeout=params.get('_request_timeout'),
3519                                        collection_formats=collection_formats)