docusign_esign.apis.connect_api

   1# coding: utf-8
   2
   3"""
   4    Docusign eSignature REST API
   5
   6    The Docusign eSignature 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 ConnectApi(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_configuration(self, account_id, **kwargs):
  44        """
  45        Creates a connect configuration for the specified account.
  46        Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide].  ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal.
  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_configuration(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 ConnectCustomConfiguration connect_custom_configuration:
  59        :return: ConnectCustomConfiguration
  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_configuration_with_http_info(account_id, **kwargs)
  66        else:
  67            (data) = self.create_configuration_with_http_info(account_id, **kwargs)
  68            return data
  69
  70    def create_configuration_with_http_info(self, account_id, **kwargs):
  71        """
  72        Creates a connect configuration for the specified account.
  73        Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide].  ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal.
  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_configuration_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 ConnectCustomConfiguration connect_custom_configuration:
  86        :return: ConnectCustomConfiguration
  87                 If the method is called asynchronously,
  88                 returns the request thread.
  89        """
  90
  91        all_params = ['account_id', 'connect_custom_configuration']
  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_configuration" % 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_configuration`")
 109
 110
 111        collection_formats = {}
 112
 113        resource_path = '/v2.1/accounts/{accountId}/connect'.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 'connect_custom_configuration' in params:
 127            body_params = params['connect_custom_configuration']
 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='ConnectCustomConfiguration',
 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_connect_o_auth_config(self, account_id, **kwargs):
 151        """
 152        Sets the Connect OAuth Config for the account.
 153        This method makes a synchronous HTTP request by default. To make an
 154        asynchronous HTTP request, please define a `callback` function
 155        to be invoked when receiving the response.
 156        >>> def callback_function(response):
 157        >>>     pprint(response)
 158        >>>
 159        >>> thread = api.create_connect_o_auth_config(account_id, callback=callback_function)
 160
 161        :param callback function: The callback function
 162            for asynchronous request. (optional)
 163        :param str account_id: The external account number (int) or account ID Guid. (required)
 164        :param ConnectOAuthConfig connect_o_auth_config:
 165        :return: ConnectOAuthConfig
 166                 If the method is called asynchronously,
 167                 returns the request thread.
 168        """
 169        kwargs['_return_http_data_only'] = True
 170        if kwargs.get('callback'):
 171            return self.create_connect_o_auth_config_with_http_info(account_id, **kwargs)
 172        else:
 173            (data) = self.create_connect_o_auth_config_with_http_info(account_id, **kwargs)
 174            return data
 175
 176    def create_connect_o_auth_config_with_http_info(self, account_id, **kwargs):
 177        """
 178        Sets the Connect OAuth Config for the account.
 179        This method makes a synchronous HTTP request by default. To make an
 180        asynchronous HTTP request, please define a `callback` function
 181        to be invoked when receiving the response.
 182        >>> def callback_function(response):
 183        >>>     pprint(response)
 184        >>>
 185        >>> thread = api.create_connect_o_auth_config_with_http_info(account_id, callback=callback_function)
 186
 187        :param callback function: The callback function
 188            for asynchronous request. (optional)
 189        :param str account_id: The external account number (int) or account ID Guid. (required)
 190        :param ConnectOAuthConfig connect_o_auth_config:
 191        :return: ConnectOAuthConfig
 192                 If the method is called asynchronously,
 193                 returns the request thread.
 194        """
 195
 196        all_params = ['account_id', 'connect_o_auth_config']
 197        all_params.append('callback')
 198        all_params.append('_return_http_data_only')
 199        all_params.append('_preload_content')
 200        all_params.append('_request_timeout')
 201
 202        params = locals()
 203        for key, val in iteritems(params['kwargs']):
 204            if key not in all_params:
 205                raise TypeError(
 206                    "Got an unexpected keyword argument '%s'"
 207                    " to method create_connect_o_auth_config" % key
 208                )
 209            params[key] = val
 210        del params['kwargs']
 211        # verify the required parameter 'account_id' is set
 212        if ('account_id' not in params) or (params['account_id'] is None):
 213            raise ValueError("Missing the required parameter `account_id` when calling `create_connect_o_auth_config`")
 214
 215
 216        collection_formats = {}
 217
 218        resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json')
 219        path_params = {}
 220        if 'account_id' in params:
 221            path_params['accountId'] = params['account_id']
 222
 223        query_params = {}
 224
 225        header_params = {}
 226
 227        form_params = []
 228        local_var_files = {}
 229
 230        body_params = None
 231        if 'connect_o_auth_config' in params:
 232            body_params = params['connect_o_auth_config']
 233        # HTTP header `Accept`
 234        header_params['Accept'] = self.api_client.\
 235            select_header_accept(['application/json'])
 236
 237        # Authentication setting
 238        auth_settings = []
 239
 240        return self.api_client.call_api(resource_path, 'POST',
 241                                        path_params,
 242                                        query_params,
 243                                        header_params,
 244                                        body=body_params,
 245                                        post_params=form_params,
 246                                        files=local_var_files,
 247                                        response_type='ConnectOAuthConfig',
 248                                        auth_settings=auth_settings,
 249                                        callback=params.get('callback'),
 250                                        _return_http_data_only=params.get('_return_http_data_only'),
 251                                        _preload_content=params.get('_preload_content', True),
 252                                        _request_timeout=params.get('_request_timeout'),
 253                                        collection_formats=collection_formats)
 254
 255    def delete_configuration(self, account_id, connect_id, **kwargs):
 256        """
 257        Deletes the specified connect configuration.
 258        Deletes the specified DocuSign Connect configuration.  ###### Note: Connect must be enabled for your account to use this function.    
 259        This method makes a synchronous HTTP request by default. To make an
 260        asynchronous HTTP request, please define a `callback` function
 261        to be invoked when receiving the response.
 262        >>> def callback_function(response):
 263        >>>     pprint(response)
 264        >>>
 265        >>> thread = api.delete_configuration(account_id, connect_id, callback=callback_function)
 266
 267        :param callback function: The callback function
 268            for asynchronous request. (optional)
 269        :param str account_id: The external account number (int) or account ID Guid. (required)
 270        :param str connect_id: The ID of the custom Connect configuration being accessed. (required)
 271        :return: None
 272                 If the method is called asynchronously,
 273                 returns the request thread.
 274        """
 275        kwargs['_return_http_data_only'] = True
 276        if kwargs.get('callback'):
 277            return self.delete_configuration_with_http_info(account_id, connect_id, **kwargs)
 278        else:
 279            (data) = self.delete_configuration_with_http_info(account_id, connect_id, **kwargs)
 280            return data
 281
 282    def delete_configuration_with_http_info(self, account_id, connect_id, **kwargs):
 283        """
 284        Deletes the specified connect configuration.
 285        Deletes the specified DocuSign Connect configuration.  ###### Note: Connect must be enabled for your account to use this function.    
 286        This method makes a synchronous HTTP request by default. To make an
 287        asynchronous HTTP request, please define a `callback` function
 288        to be invoked when receiving the response.
 289        >>> def callback_function(response):
 290        >>>     pprint(response)
 291        >>>
 292        >>> thread = api.delete_configuration_with_http_info(account_id, connect_id, callback=callback_function)
 293
 294        :param callback function: The callback function
 295            for asynchronous request. (optional)
 296        :param str account_id: The external account number (int) or account ID Guid. (required)
 297        :param str connect_id: The ID of the custom Connect configuration being accessed. (required)
 298        :return: None
 299                 If the method is called asynchronously,
 300                 returns the request thread.
 301        """
 302
 303        all_params = ['account_id', 'connect_id']
 304        all_params.append('callback')
 305        all_params.append('_return_http_data_only')
 306        all_params.append('_preload_content')
 307        all_params.append('_request_timeout')
 308
 309        params = locals()
 310        for key, val in iteritems(params['kwargs']):
 311            if key not in all_params:
 312                raise TypeError(
 313                    "Got an unexpected keyword argument '%s'"
 314                    " to method delete_configuration" % key
 315                )
 316            params[key] = val
 317        del params['kwargs']
 318        # verify the required parameter 'account_id' is set
 319        if ('account_id' not in params) or (params['account_id'] is None):
 320            raise ValueError("Missing the required parameter `account_id` when calling `delete_configuration`")
 321        # verify the required parameter 'connect_id' is set
 322        if ('connect_id' not in params) or (params['connect_id'] is None):
 323            raise ValueError("Missing the required parameter `connect_id` when calling `delete_configuration`")
 324
 325
 326        collection_formats = {}
 327
 328        resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json')
 329        path_params = {}
 330        if 'account_id' in params:
 331            path_params['accountId'] = params['account_id']
 332        if 'connect_id' in params:
 333            path_params['connectId'] = params['connect_id']
 334
 335        query_params = {}
 336
 337        header_params = {}
 338
 339        form_params = []
 340        local_var_files = {}
 341
 342        body_params = None
 343        # HTTP header `Accept`
 344        header_params['Accept'] = self.api_client.\
 345            select_header_accept(['application/json'])
 346
 347        # Authentication setting
 348        auth_settings = []
 349
 350        return self.api_client.call_api(resource_path, 'DELETE',
 351                                        path_params,
 352                                        query_params,
 353                                        header_params,
 354                                        body=body_params,
 355                                        post_params=form_params,
 356                                        files=local_var_files,
 357                                        response_type=None,
 358                                        auth_settings=auth_settings,
 359                                        callback=params.get('callback'),
 360                                        _return_http_data_only=params.get('_return_http_data_only'),
 361                                        _preload_content=params.get('_preload_content', True),
 362                                        _request_timeout=params.get('_request_timeout'),
 363                                        collection_formats=collection_formats)
 364
 365    def delete_connect_o_auth_config(self, account_id, **kwargs):
 366        """
 367        Sets the Connect OAuth Config for the account.
 368        This method makes a synchronous HTTP request by default. To make an
 369        asynchronous HTTP request, please define a `callback` function
 370        to be invoked when receiving the response.
 371        >>> def callback_function(response):
 372        >>>     pprint(response)
 373        >>>
 374        >>> thread = api.delete_connect_o_auth_config(account_id, callback=callback_function)
 375
 376        :param callback function: The callback function
 377            for asynchronous request. (optional)
 378        :param str account_id: The external account number (int) or account ID Guid. (required)
 379        :return: None
 380                 If the method is called asynchronously,
 381                 returns the request thread.
 382        """
 383        kwargs['_return_http_data_only'] = True
 384        if kwargs.get('callback'):
 385            return self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs)
 386        else:
 387            (data) = self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs)
 388            return data
 389
 390    def delete_connect_o_auth_config_with_http_info(self, account_id, **kwargs):
 391        """
 392        Sets the Connect OAuth Config for the account.
 393        This method makes a synchronous HTTP request by default. To make an
 394        asynchronous HTTP request, please define a `callback` function
 395        to be invoked when receiving the response.
 396        >>> def callback_function(response):
 397        >>>     pprint(response)
 398        >>>
 399        >>> thread = api.delete_connect_o_auth_config_with_http_info(account_id, callback=callback_function)
 400
 401        :param callback function: The callback function
 402            for asynchronous request. (optional)
 403        :param str account_id: The external account number (int) or account ID Guid. (required)
 404        :return: None
 405                 If the method is called asynchronously,
 406                 returns the request thread.
 407        """
 408
 409        all_params = ['account_id']
 410        all_params.append('callback')
 411        all_params.append('_return_http_data_only')
 412        all_params.append('_preload_content')
 413        all_params.append('_request_timeout')
 414
 415        params = locals()
 416        for key, val in iteritems(params['kwargs']):
 417            if key not in all_params:
 418                raise TypeError(
 419                    "Got an unexpected keyword argument '%s'"
 420                    " to method delete_connect_o_auth_config" % key
 421                )
 422            params[key] = val
 423        del params['kwargs']
 424        # verify the required parameter 'account_id' is set
 425        if ('account_id' not in params) or (params['account_id'] is None):
 426            raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_o_auth_config`")
 427
 428
 429        collection_formats = {}
 430
 431        resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json')
 432        path_params = {}
 433        if 'account_id' in params:
 434            path_params['accountId'] = params['account_id']
 435
 436        query_params = {}
 437
 438        header_params = {}
 439
 440        form_params = []
 441        local_var_files = {}
 442
 443        body_params = None
 444        # HTTP header `Accept`
 445        header_params['Accept'] = self.api_client.\
 446            select_header_accept(['application/json'])
 447
 448        # Authentication setting
 449        auth_settings = []
 450
 451        return self.api_client.call_api(resource_path, 'DELETE',
 452                                        path_params,
 453                                        query_params,
 454                                        header_params,
 455                                        body=body_params,
 456                                        post_params=form_params,
 457                                        files=local_var_files,
 458                                        response_type=None,
 459                                        auth_settings=auth_settings,
 460                                        callback=params.get('callback'),
 461                                        _return_http_data_only=params.get('_return_http_data_only'),
 462                                        _preload_content=params.get('_preload_content', True),
 463                                        _request_timeout=params.get('_request_timeout'),
 464                                        collection_formats=collection_formats)
 465
 466    def delete_event_failure_log(self, account_id, failure_id, **kwargs):
 467        """
 468        Deletes a Connect failure log entry.
 469        Deletes the Connect failure log information for the specified entry.
 470        This method makes a synchronous HTTP request by default. To make an
 471        asynchronous HTTP request, please define a `callback` function
 472        to be invoked when receiving the response.
 473        >>> def callback_function(response):
 474        >>>     pprint(response)
 475        >>>
 476        >>> thread = api.delete_event_failure_log(account_id, failure_id, callback=callback_function)
 477
 478        :param callback function: The callback function
 479            for asynchronous request. (optional)
 480        :param str account_id: The external account number (int) or account ID Guid. (required)
 481        :param str failure_id: The ID of the failed connect log entry. (required)
 482        :return: ConnectDeleteFailureResult
 483                 If the method is called asynchronously,
 484                 returns the request thread.
 485        """
 486        kwargs['_return_http_data_only'] = True
 487        if kwargs.get('callback'):
 488            return self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs)
 489        else:
 490            (data) = self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs)
 491            return data
 492
 493    def delete_event_failure_log_with_http_info(self, account_id, failure_id, **kwargs):
 494        """
 495        Deletes a Connect failure log entry.
 496        Deletes the Connect failure log information for the specified entry.
 497        This method makes a synchronous HTTP request by default. To make an
 498        asynchronous HTTP request, please define a `callback` function
 499        to be invoked when receiving the response.
 500        >>> def callback_function(response):
 501        >>>     pprint(response)
 502        >>>
 503        >>> thread = api.delete_event_failure_log_with_http_info(account_id, failure_id, callback=callback_function)
 504
 505        :param callback function: The callback function
 506            for asynchronous request. (optional)
 507        :param str account_id: The external account number (int) or account ID Guid. (required)
 508        :param str failure_id: The ID of the failed connect log entry. (required)
 509        :return: ConnectDeleteFailureResult
 510                 If the method is called asynchronously,
 511                 returns the request thread.
 512        """
 513
 514        all_params = ['account_id', 'failure_id']
 515        all_params.append('callback')
 516        all_params.append('_return_http_data_only')
 517        all_params.append('_preload_content')
 518        all_params.append('_request_timeout')
 519
 520        params = locals()
 521        for key, val in iteritems(params['kwargs']):
 522            if key not in all_params:
 523                raise TypeError(
 524                    "Got an unexpected keyword argument '%s'"
 525                    " to method delete_event_failure_log" % key
 526                )
 527            params[key] = val
 528        del params['kwargs']
 529        # verify the required parameter 'account_id' is set
 530        if ('account_id' not in params) or (params['account_id'] is None):
 531            raise ValueError("Missing the required parameter `account_id` when calling `delete_event_failure_log`")
 532        # verify the required parameter 'failure_id' is set
 533        if ('failure_id' not in params) or (params['failure_id'] is None):
 534            raise ValueError("Missing the required parameter `failure_id` when calling `delete_event_failure_log`")
 535
 536
 537        collection_formats = {}
 538
 539        resource_path = '/v2.1/accounts/{accountId}/connect/failures/{failureId}'.replace('{format}', 'json')
 540        path_params = {}
 541        if 'account_id' in params:
 542            path_params['accountId'] = params['account_id']
 543        if 'failure_id' in params:
 544            path_params['failureId'] = params['failure_id']
 545
 546        query_params = {}
 547
 548        header_params = {}
 549
 550        form_params = []
 551        local_var_files = {}
 552
 553        body_params = None
 554        # HTTP header `Accept`
 555        header_params['Accept'] = self.api_client.\
 556            select_header_accept(['application/json'])
 557
 558        # Authentication setting
 559        auth_settings = []
 560
 561        return self.api_client.call_api(resource_path, 'DELETE',
 562                                        path_params,
 563                                        query_params,
 564                                        header_params,
 565                                        body=body_params,
 566                                        post_params=form_params,
 567                                        files=local_var_files,
 568                                        response_type='ConnectDeleteFailureResult',
 569                                        auth_settings=auth_settings,
 570                                        callback=params.get('callback'),
 571                                        _return_http_data_only=params.get('_return_http_data_only'),
 572                                        _preload_content=params.get('_preload_content', True),
 573                                        _request_timeout=params.get('_request_timeout'),
 574                                        collection_formats=collection_formats)
 575
 576    def delete_event_log(self, account_id, log_id, **kwargs):
 577        """
 578        Deletes a specified Connect log entry.
 579        Deletes a specified entry from the Connect Log. 
 580        This method makes a synchronous HTTP request by default. To make an
 581        asynchronous HTTP request, please define a `callback` function
 582        to be invoked when receiving the response.
 583        >>> def callback_function(response):
 584        >>>     pprint(response)
 585        >>>
 586        >>> thread = api.delete_event_log(account_id, log_id, callback=callback_function)
 587
 588        :param callback function: The callback function
 589            for asynchronous request. (optional)
 590        :param str account_id: The external account number (int) or account ID Guid. (required)
 591        :param str log_id: The ID of the connect log entry (required)
 592        :return: None
 593                 If the method is called asynchronously,
 594                 returns the request thread.
 595        """
 596        kwargs['_return_http_data_only'] = True
 597        if kwargs.get('callback'):
 598            return self.delete_event_log_with_http_info(account_id, log_id, **kwargs)
 599        else:
 600            (data) = self.delete_event_log_with_http_info(account_id, log_id, **kwargs)
 601            return data
 602
 603    def delete_event_log_with_http_info(self, account_id, log_id, **kwargs):
 604        """
 605        Deletes a specified Connect log entry.
 606        Deletes a specified entry from the Connect Log. 
 607        This method makes a synchronous HTTP request by default. To make an
 608        asynchronous HTTP request, please define a `callback` function
 609        to be invoked when receiving the response.
 610        >>> def callback_function(response):
 611        >>>     pprint(response)
 612        >>>
 613        >>> thread = api.delete_event_log_with_http_info(account_id, log_id, callback=callback_function)
 614
 615        :param callback function: The callback function
 616            for asynchronous request. (optional)
 617        :param str account_id: The external account number (int) or account ID Guid. (required)
 618        :param str log_id: The ID of the connect log entry (required)
 619        :return: None
 620                 If the method is called asynchronously,
 621                 returns the request thread.
 622        """
 623
 624        all_params = ['account_id', 'log_id']
 625        all_params.append('callback')
 626        all_params.append('_return_http_data_only')
 627        all_params.append('_preload_content')
 628        all_params.append('_request_timeout')
 629
 630        params = locals()
 631        for key, val in iteritems(params['kwargs']):
 632            if key not in all_params:
 633                raise TypeError(
 634                    "Got an unexpected keyword argument '%s'"
 635                    " to method delete_event_log" % key
 636                )
 637            params[key] = val
 638        del params['kwargs']
 639        # verify the required parameter 'account_id' is set
 640        if ('account_id' not in params) or (params['account_id'] is None):
 641            raise ValueError("Missing the required parameter `account_id` when calling `delete_event_log`")
 642        # verify the required parameter 'log_id' is set
 643        if ('log_id' not in params) or (params['log_id'] is None):
 644            raise ValueError("Missing the required parameter `log_id` when calling `delete_event_log`")
 645
 646
 647        collection_formats = {}
 648
 649        resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json')
 650        path_params = {}
 651        if 'account_id' in params:
 652            path_params['accountId'] = params['account_id']
 653        if 'log_id' in params:
 654            path_params['logId'] = params['log_id']
 655
 656        query_params = {}
 657
 658        header_params = {}
 659
 660        form_params = []
 661        local_var_files = {}
 662
 663        body_params = None
 664        # HTTP header `Accept`
 665        header_params['Accept'] = self.api_client.\
 666            select_header_accept(['application/json'])
 667
 668        # Authentication setting
 669        auth_settings = []
 670
 671        return self.api_client.call_api(resource_path, 'DELETE',
 672                                        path_params,
 673                                        query_params,
 674                                        header_params,
 675                                        body=body_params,
 676                                        post_params=form_params,
 677                                        files=local_var_files,
 678                                        response_type=None,
 679                                        auth_settings=auth_settings,
 680                                        callback=params.get('callback'),
 681                                        _return_http_data_only=params.get('_return_http_data_only'),
 682                                        _preload_content=params.get('_preload_content', True),
 683                                        _request_timeout=params.get('_request_timeout'),
 684                                        collection_formats=collection_formats)
 685
 686    def delete_event_logs(self, account_id, **kwargs):
 687        """
 688        Gets a list of Connect log entries.
 689        Retrieves a list of connect log entries for your account.  ###### Note: The `enableLog` property in the Connect configuration must be set to **true** to enable logging. If logging is not enabled, then no log entries are recorded.
 690        This method makes a synchronous HTTP request by default. To make an
 691        asynchronous HTTP request, please define a `callback` function
 692        to be invoked when receiving the response.
 693        >>> def callback_function(response):
 694        >>>     pprint(response)
 695        >>>
 696        >>> thread = api.delete_event_logs(account_id, callback=callback_function)
 697
 698        :param callback function: The callback function
 699            for asynchronous request. (optional)
 700        :param str account_id: The external account number (int) or account ID Guid. (required)
 701        :return: None
 702                 If the method is called asynchronously,
 703                 returns the request thread.
 704        """
 705        kwargs['_return_http_data_only'] = True
 706        if kwargs.get('callback'):
 707            return self.delete_event_logs_with_http_info(account_id, **kwargs)
 708        else:
 709            (data) = self.delete_event_logs_with_http_info(account_id, **kwargs)
 710            return data
 711
 712    def delete_event_logs_with_http_info(self, account_id, **kwargs):
 713        """
 714        Gets a list of Connect log entries.
 715        Retrieves a list of connect log entries for your account.  ###### Note: The `enableLog` property in the Connect configuration must be set to **true** to enable logging. If logging is not enabled, then no log entries are recorded.
 716        This method makes a synchronous HTTP request by default. To make an
 717        asynchronous HTTP request, please define a `callback` function
 718        to be invoked when receiving the response.
 719        >>> def callback_function(response):
 720        >>>     pprint(response)
 721        >>>
 722        >>> thread = api.delete_event_logs_with_http_info(account_id, callback=callback_function)
 723
 724        :param callback function: The callback function
 725            for asynchronous request. (optional)
 726        :param str account_id: The external account number (int) or account ID Guid. (required)
 727        :return: None
 728                 If the method is called asynchronously,
 729                 returns the request thread.
 730        """
 731
 732        all_params = ['account_id']
 733        all_params.append('callback')
 734        all_params.append('_return_http_data_only')
 735        all_params.append('_preload_content')
 736        all_params.append('_request_timeout')
 737
 738        params = locals()
 739        for key, val in iteritems(params['kwargs']):
 740            if key not in all_params:
 741                raise TypeError(
 742                    "Got an unexpected keyword argument '%s'"
 743                    " to method delete_event_logs" % key
 744                )
 745            params[key] = val
 746        del params['kwargs']
 747        # verify the required parameter 'account_id' is set
 748        if ('account_id' not in params) or (params['account_id'] is None):
 749            raise ValueError("Missing the required parameter `account_id` when calling `delete_event_logs`")
 750
 751
 752        collection_formats = {}
 753
 754        resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json')
 755        path_params = {}
 756        if 'account_id' in params:
 757            path_params['accountId'] = params['account_id']
 758
 759        query_params = {}
 760
 761        header_params = {}
 762
 763        form_params = []
 764        local_var_files = {}
 765
 766        body_params = None
 767        # HTTP header `Accept`
 768        header_params['Accept'] = self.api_client.\
 769            select_header_accept(['application/json'])
 770
 771        # Authentication setting
 772        auth_settings = []
 773
 774        return self.api_client.call_api(resource_path, 'DELETE',
 775                                        path_params,
 776                                        query_params,
 777                                        header_params,
 778                                        body=body_params,
 779                                        post_params=form_params,
 780                                        files=local_var_files,
 781                                        response_type=None,
 782                                        auth_settings=auth_settings,
 783                                        callback=params.get('callback'),
 784                                        _return_http_data_only=params.get('_return_http_data_only'),
 785                                        _preload_content=params.get('_preload_content', True),
 786                                        _request_timeout=params.get('_request_timeout'),
 787                                        collection_formats=collection_formats)
 788
 789    def delete_mobile_notifiers(self, account_id, **kwargs):
 790        """
 791        Reserved
 792        Reserved:
 793        This method makes a synchronous HTTP request by default. To make an
 794        asynchronous HTTP request, please define a `callback` function
 795        to be invoked when receiving the response.
 796        >>> def callback_function(response):
 797        >>>     pprint(response)
 798        >>>
 799        >>> thread = api.delete_mobile_notifiers(account_id, callback=callback_function)
 800
 801        :param callback function: The callback function
 802            for asynchronous request. (optional)
 803        :param str account_id: The external account number (int) or account ID Guid. (required)
 804        :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information:
 805        :return: MobileNotifierConfigurationInformation
 806                 If the method is called asynchronously,
 807                 returns the request thread.
 808        """
 809        kwargs['_return_http_data_only'] = True
 810        if kwargs.get('callback'):
 811            return self.delete_mobile_notifiers_with_http_info(account_id, **kwargs)
 812        else:
 813            (data) = self.delete_mobile_notifiers_with_http_info(account_id, **kwargs)
 814            return data
 815
 816    def delete_mobile_notifiers_with_http_info(self, account_id, **kwargs):
 817        """
 818        Reserved
 819        Reserved:
 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_mobile_notifiers_with_http_info(account_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 MobileNotifierConfigurationInformation mobile_notifier_configuration_information:
 832        :return: MobileNotifierConfigurationInformation
 833                 If the method is called asynchronously,
 834                 returns the request thread.
 835        """
 836
 837        all_params = ['account_id', 'mobile_notifier_configuration_information']
 838        all_params.append('callback')
 839        all_params.append('_return_http_data_only')
 840        all_params.append('_preload_content')
 841        all_params.append('_request_timeout')
 842
 843        params = locals()
 844        for key, val in iteritems(params['kwargs']):
 845            if key not in all_params:
 846                raise TypeError(
 847                    "Got an unexpected keyword argument '%s'"
 848                    " to method delete_mobile_notifiers" % key
 849                )
 850            params[key] = val
 851        del params['kwargs']
 852        # verify the required parameter 'account_id' is set
 853        if ('account_id' not in params) or (params['account_id'] is None):
 854            raise ValueError("Missing the required parameter `account_id` when calling `delete_mobile_notifiers`")
 855
 856
 857        collection_formats = {}
 858
 859        resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json')
 860        path_params = {}
 861        if 'account_id' in params:
 862            path_params['accountId'] = params['account_id']
 863
 864        query_params = {}
 865
 866        header_params = {}
 867
 868        form_params = []
 869        local_var_files = {}
 870
 871        body_params = None
 872        if 'mobile_notifier_configuration_information' in params:
 873            body_params = params['mobile_notifier_configuration_information']
 874        # HTTP header `Accept`
 875        header_params['Accept'] = self.api_client.\
 876            select_header_accept(['application/json'])
 877
 878        # Authentication setting
 879        auth_settings = []
 880
 881        return self.api_client.call_api(resource_path, 'DELETE',
 882                                        path_params,
 883                                        query_params,
 884                                        header_params,
 885                                        body=body_params,
 886                                        post_params=form_params,
 887                                        files=local_var_files,
 888                                        response_type='MobileNotifierConfigurationInformation',
 889                                        auth_settings=auth_settings,
 890                                        callback=params.get('callback'),
 891                                        _return_http_data_only=params.get('_return_http_data_only'),
 892                                        _preload_content=params.get('_preload_content', True),
 893                                        _request_timeout=params.get('_request_timeout'),
 894                                        collection_formats=collection_formats)
 895
 896    def get_configuration(self, account_id, connect_id, **kwargs):
 897        """
 898        Get a Connect Configuration Information
 899        Retrieves the information for the specified DocuSign Connect configuration.  ###### Note: Connect must be enabled for your account to use this function. 
 900        This method makes a synchronous HTTP request by default. To make an
 901        asynchronous HTTP request, please define a `callback` function
 902        to be invoked when receiving the response.
 903        >>> def callback_function(response):
 904        >>>     pprint(response)
 905        >>>
 906        >>> thread = api.get_configuration(account_id, connect_id, callback=callback_function)
 907
 908        :param callback function: The callback function
 909            for asynchronous request. (optional)
 910        :param str account_id: The external account number (int) or account ID Guid. (required)
 911        :param str connect_id: The ID of the custom Connect configuration being accessed. (required)
 912        :return: ConnectConfigResults
 913                 If the method is called asynchronously,
 914                 returns the request thread.
 915        """
 916        kwargs['_return_http_data_only'] = True
 917        if kwargs.get('callback'):
 918            return self.get_configuration_with_http_info(account_id, connect_id, **kwargs)
 919        else:
 920            (data) = self.get_configuration_with_http_info(account_id, connect_id, **kwargs)
 921            return data
 922
 923    def get_configuration_with_http_info(self, account_id, connect_id, **kwargs):
 924        """
 925        Get a Connect Configuration Information
 926        Retrieves the information for the specified DocuSign Connect configuration.  ###### Note: Connect must be enabled for your account to use this function. 
 927        This method makes a synchronous HTTP request by default. To make an
 928        asynchronous HTTP request, please define a `callback` function
 929        to be invoked when receiving the response.
 930        >>> def callback_function(response):
 931        >>>     pprint(response)
 932        >>>
 933        >>> thread = api.get_configuration_with_http_info(account_id, connect_id, callback=callback_function)
 934
 935        :param callback function: The callback function
 936            for asynchronous request. (optional)
 937        :param str account_id: The external account number (int) or account ID Guid. (required)
 938        :param str connect_id: The ID of the custom Connect configuration being accessed. (required)
 939        :return: ConnectConfigResults
 940                 If the method is called asynchronously,
 941                 returns the request thread.
 942        """
 943
 944        all_params = ['account_id', 'connect_id']
 945        all_params.append('callback')
 946        all_params.append('_return_http_data_only')
 947        all_params.append('_preload_content')
 948        all_params.append('_request_timeout')
 949
 950        params = locals()
 951        for key, val in iteritems(params['kwargs']):
 952            if key not in all_params:
 953                raise TypeError(
 954                    "Got an unexpected keyword argument '%s'"
 955                    " to method get_configuration" % key
 956                )
 957            params[key] = val
 958        del params['kwargs']
 959        # verify the required parameter 'account_id' is set
 960        if ('account_id' not in params) or (params['account_id'] is None):
 961            raise ValueError("Missing the required parameter `account_id` when calling `get_configuration`")
 962        # verify the required parameter 'connect_id' is set
 963        if ('connect_id' not in params) or (params['connect_id'] is None):
 964            raise ValueError("Missing the required parameter `connect_id` when calling `get_configuration`")
 965
 966
 967        collection_formats = {}
 968
 969        resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json')
 970        path_params = {}
 971        if 'account_id' in params:
 972            path_params['accountId'] = params['account_id']
 973        if 'connect_id' in params:
 974            path_params['connectId'] = params['connect_id']
 975
 976        query_params = {}
 977
 978        header_params = {}
 979
 980        form_params = []
 981        local_var_files = {}
 982
 983        body_params = None
 984        # HTTP header `Accept`
 985        header_params['Accept'] = self.api_client.\
 986            select_header_accept(['application/json'])
 987
 988        # Authentication setting
 989        auth_settings = []
 990
 991        return self.api_client.call_api(resource_path, 'GET',
 992                                        path_params,
 993                                        query_params,
 994                                        header_params,
 995                                        body=body_params,
 996                                        post_params=form_params,
 997                                        files=local_var_files,
 998                                        response_type='ConnectConfigResults',
 999                                        auth_settings=auth_settings,
1000                                        callback=params.get('callback'),
1001                                        _return_http_data_only=params.get('_return_http_data_only'),
1002                                        _preload_content=params.get('_preload_content', True),
1003                                        _request_timeout=params.get('_request_timeout'),
1004                                        collection_formats=collection_formats)
1005
1006    def get_connect_all_users(self, account_id, connect_id, **kwargs):
1007        """
1008        Returns all users from the configured Connect service.
1009        
1010        This method makes a synchronous HTTP request by default. To make an
1011        asynchronous HTTP request, please define a `callback` function
1012        to be invoked when receiving the response.
1013        >>> def callback_function(response):
1014        >>>     pprint(response)
1015        >>>
1016        >>> thread = api.get_connect_all_users(account_id, connect_id, callback=callback_function)
1017
1018        :param callback function: The callback function
1019            for asynchronous request. (optional)
1020        :param str account_id: The external account number (int) or account ID Guid. (required)
1021        :param str connect_id: The ID of the custom Connect configuration being accessed. (required)
1022        :param str count:
1023        :param str domain_users_only:
1024        :param str email_substring:
1025        :param str start_position:
1026        :param str status:
1027        :param str user_name_substring:
1028        :return: IntegratedConnectUserInfoList
1029                 If the method is called asynchronously,
1030                 returns the request thread.
1031        """
1032        kwargs['_return_http_data_only'] = True
1033        if kwargs.get('callback'):
1034            return self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs)
1035        else:
1036            (data) = self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs)
1037            return data
1038
1039    def get_connect_all_users_with_http_info(self, account_id, connect_id, **kwargs):
1040        """
1041        Returns all users from the configured Connect service.
1042        
1043        This method makes a synchronous HTTP request by default. To make an
1044        asynchronous HTTP request, please define a `callback` function
1045        to be invoked when receiving the response.
1046        >>> def callback_function(response):
1047        >>>     pprint(response)
1048        >>>
1049        >>> thread = api.get_connect_all_users_with_http_info(account_id, connect_id, callback=callback_function)
1050
1051        :param callback function: The callback function
1052            for asynchronous request. (optional)
1053        :param str account_id: The external account number (int) or account ID Guid. (required)
1054        :param str connect_id: The ID of the custom Connect configuration being accessed. (required)
1055        :param str count:
1056        :param str domain_users_only:
1057        :param str email_substring:
1058        :param str start_position:
1059        :param str status:
1060        :param str user_name_substring:
1061        :return: IntegratedConnectUserInfoList
1062                 If the method is called asynchronously,
1063                 returns the request thread.
1064        """
1065
1066        all_params = ['account_id', 'connect_id', 'count', 'domain_users_only', 'email_substring', 'start_position', 'status', 'user_name_substring']
1067        all_params.append('callback')
1068        all_params.append('_return_http_data_only')
1069        all_params.append('_preload_content')
1070        all_params.append('_request_timeout')
1071
1072        params = locals()
1073        for key, val in iteritems(params['kwargs']):
1074            if key not in all_params:
1075                raise TypeError(
1076                    "Got an unexpected keyword argument '%s'"
1077                    " to method get_connect_all_users" % key
1078                )
1079            params[key] = val
1080        del params['kwargs']
1081        # verify the required parameter 'account_id' is set
1082        if ('account_id' not in params) or (params['account_id'] is None):
1083            raise ValueError("Missing the required parameter `account_id` when calling `get_connect_all_users`")
1084        # verify the required parameter 'connect_id' is set
1085        if ('connect_id' not in params) or (params['connect_id'] is None):
1086            raise ValueError("Missing the required parameter `connect_id` when calling `get_connect_all_users`")
1087
1088
1089        collection_formats = {}
1090
1091        resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/all/users'.replace('{format}', 'json')
1092        path_params = {}
1093        if 'account_id' in params:
1094            path_params['accountId'] = params['account_id']
1095        if 'connect_id' in params:
1096            path_params['connectId'] = params['connect_id']
1097
1098        query_params = {}
1099        if 'count' in params:
1100            query_params['count'] = params['count']
1101        if 'domain_users_only' in params:
1102            query_params['domain_users_only'] = params['domain_users_only']
1103        if 'email_substring' in params:
1104            query_params['email_substring'] = params['email_substring']
1105        if 'start_position' in params:
1106            query_params['start_position'] = params['start_position']
1107        if 'status' in params:
1108            query_params['status'] = params['status']
1109        if 'user_name_substring' in params:
1110            query_params['user_name_substring'] = params['user_name_substring']
1111
1112        header_params = {}
1113
1114        form_params = []
1115        local_var_files = {}
1116
1117        body_params = None
1118        # HTTP header `Accept`
1119        header_params['Accept'] = self.api_client.\
1120            select_header_accept(['application/json'])
1121
1122        # Authentication setting
1123        auth_settings = []
1124
1125        return self.api_client.call_api(resource_path, 'GET',
1126                                        path_params,
1127                                        query_params,
1128                                        header_params,
1129                                        body=body_params,
1130                                        post_params=form_params,
1131                                        files=local_var_files,
1132                                        response_type='IntegratedConnectUserInfoList',
1133                                        auth_settings=auth_settings,
1134                                        callback=params.get('callback'),
1135                                        _return_http_data_only=params.get('_return_http_data_only'),
1136                                        _preload_content=params.get('_preload_content', True),
1137                                        _request_timeout=params.get('_request_timeout'),
1138                                        collection_formats=collection_formats)
1139
1140    def get_connect_o_auth_config(self, account_id, **kwargs):
1141        """
1142        Sets the Connect OAuth Config for the account.
1143        This method makes a synchronous HTTP request by default. To make an
1144        asynchronous HTTP request, please define a `callback` function
1145        to be invoked when receiving the response.
1146        >>> def callback_function(response):
1147        >>>     pprint(response)
1148        >>>
1149        >>> thread = api.get_connect_o_auth_config(account_id, callback=callback_function)
1150
1151        :param callback function: The callback function
1152            for asynchronous request. (optional)
1153        :param str account_id: The external account number (int) or account ID Guid. (required)
1154        :return: ConnectOAuthConfig
1155                 If the method is called asynchronously,
1156                 returns the request thread.
1157        """
1158        kwargs['_return_http_data_only'] = True
1159        if kwargs.get('callback'):
1160            return self.get_connect_o_auth_config_with_http_info(account_id, **kwargs)
1161        else:
1162            (data) = self.get_connect_o_auth_config_with_http_info(account_id, **kwargs)
1163            return data
1164
1165    def get_connect_o_auth_config_with_http_info(self, account_id, **kwargs):
1166        """
1167        Sets the Connect OAuth Config for the account.
1168        This method makes a synchronous HTTP request by default. To make an
1169        asynchronous HTTP request, please define a `callback` function
1170        to be invoked when receiving the response.
1171        >>> def callback_function(response):
1172        >>>     pprint(response)
1173        >>>
1174        >>> thread = api.get_connect_o_auth_config_with_http_info(account_id, callback=callback_function)
1175
1176        :param callback function: The callback function
1177            for asynchronous request. (optional)
1178        :param str account_id: The external account number (int) or account ID Guid. (required)
1179        :return: ConnectOAuthConfig
1180                 If the method is called asynchronously,
1181                 returns the request thread.
1182        """
1183
1184        all_params = ['account_id']
1185        all_params.append('callback')
1186        all_params.append('_return_http_data_only')
1187        all_params.append('_preload_content')
1188        all_params.append('_request_timeout')
1189
1190        params = locals()
1191        for key, val in iteritems(params['kwargs']):
1192            if key not in all_params:
1193                raise TypeError(
1194                    "Got an unexpected keyword argument '%s'"
1195                    " to method get_connect_o_auth_config" % key
1196                )
1197            params[key] = val
1198        del params['kwargs']
1199        # verify the required parameter 'account_id' is set
1200        if ('account_id' not in params) or (params['account_id'] is None):
1201            raise ValueError("Missing the required parameter `account_id` when calling `get_connect_o_auth_config`")
1202
1203
1204        collection_formats = {}
1205
1206        resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json')
1207        path_params = {}
1208        if 'account_id' in params:
1209            path_params['accountId'] = params['account_id']
1210
1211        query_params = {}
1212
1213        header_params = {}
1214
1215        form_params = []
1216        local_var_files = {}
1217
1218        body_params = None
1219        # HTTP header `Accept`
1220        header_params['Accept'] = self.api_client.\
1221            select_header_accept(['application/json'])
1222
1223        # Authentication setting
1224        auth_settings = []
1225
1226        return self.api_client.call_api(resource_path, 'GET',
1227                                        path_params,
1228                                        query_params,
1229                                        header_params,
1230                                        body=body_params,
1231                                        post_params=form_params,
1232                                        files=local_var_files,
1233                                        response_type='ConnectOAuthConfig',
1234                                        auth_settings=auth_settings,
1235                                        callback=params.get('callback'),
1236                                        _return_http_data_only=params.get('_return_http_data_only'),
1237                                        _preload_content=params.get('_preload_content', True),
1238                                        _request_timeout=params.get('_request_timeout'),
1239                                        collection_formats=collection_formats)
1240
1241    def get_event_log(self, account_id, log_id, **kwargs):
1242        """
1243        Get the specified Connect log entry.
1244        Retrieves the specified Connect log entry for your account.  ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 
1245        This method makes a synchronous HTTP request by default. To make an
1246        asynchronous HTTP request, please define a `callback` function
1247        to be invoked when receiving the response.
1248        >>> def callback_function(response):
1249        >>>     pprint(response)
1250        >>>
1251        >>> thread = api.get_event_log(account_id, log_id, callback=callback_function)
1252
1253        :param callback function: The callback function
1254            for asynchronous request. (optional)
1255        :param str account_id: The external account number (int) or account ID Guid. (required)
1256        :param str log_id: The ID of the connect log entry (required)
1257        :param str additional_info: When true, the connectDebugLog information is included in the response.
1258        :return: ConnectLog
1259                 If the method is called asynchronously,
1260                 returns the request thread.
1261        """
1262        kwargs['_return_http_data_only'] = True
1263        if kwargs.get('callback'):
1264            return self.get_event_log_with_http_info(account_id, log_id, **kwargs)
1265        else:
1266            (data) = self.get_event_log_with_http_info(account_id, log_id, **kwargs)
1267            return data
1268
1269    def get_event_log_with_http_info(self, account_id, log_id, **kwargs):
1270        """
1271        Get the specified Connect log entry.
1272        Retrieves the specified Connect log entry for your account.  ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 
1273        This method makes a synchronous HTTP request by default. To make an
1274        asynchronous HTTP request, please define a `callback` function
1275        to be invoked when receiving the response.
1276        >>> def callback_function(response):
1277        >>>     pprint(response)
1278        >>>
1279        >>> thread = api.get_event_log_with_http_info(account_id, log_id, callback=callback_function)
1280
1281        :param callback function: The callback function
1282            for asynchronous request. (optional)
1283        :param str account_id: The external account number (int) or account ID Guid. (required)
1284        :param str log_id: The ID of the connect log entry (required)
1285        :param str additional_info: When true, the connectDebugLog information is included in the response.
1286        :return: ConnectLog
1287                 If the method is called asynchronously,
1288                 returns the request thread.
1289        """
1290
1291        all_params = ['account_id', 'log_id', 'additional_info']
1292        all_params.append('callback')
1293        all_params.append('_return_http_data_only')
1294        all_params.append('_preload_content')
1295        all_params.append('_request_timeout')
1296
1297        params = locals()
1298        for key, val in iteritems(params['kwargs']):
1299            if key not in all_params:
1300                raise TypeError(
1301                    "Got an unexpected keyword argument '%s'"
1302                    " to method get_event_log" % key
1303                )
1304            params[key] = val
1305        del params['kwargs']
1306        # verify the required parameter 'account_id' is set
1307        if ('account_id' not in params) or (params['account_id'] is None):
1308            raise ValueError("Missing the required parameter `account_id` when calling `get_event_log`")
1309        # verify the required parameter 'log_id' is set
1310        if ('log_id' not in params) or (params['log_id'] is None):
1311            raise ValueError("Missing the required parameter `log_id` when calling `get_event_log`")
1312
1313
1314        collection_formats = {}
1315
1316        resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json')
1317        path_params = {}
1318        if 'account_id' in params:
1319            path_params['accountId'] = params['account_id']
1320        if 'log_id' in params:
1321            path_params['logId'] = params['log_id']
1322
1323        query_params = {}
1324        if 'additional_info' in params:
1325            query_params['additional_info'] = params['additional_info']
1326
1327        header_params = {}
1328
1329        form_params = []
1330        local_var_files = {}
1331
1332        body_params = None
1333        # HTTP header `Accept`
1334        header_params['Accept'] = self.api_client.\
1335            select_header_accept(['application/json'])
1336
1337        # Authentication setting
1338        auth_settings = []
1339
1340        return self.api_client.call_api(resource_path, 'GET',
1341                                        path_params,
1342                                        query_params,
1343                                        header_params,
1344                                        body=body_params,
1345                                        post_params=form_params,
1346                                        files=local_var_files,
1347                                        response_type='ConnectLog',
1348                                        auth_settings=auth_settings,
1349                                        callback=params.get('callback'),
1350                                        _return_http_data_only=params.get('_return_http_data_only'),
1351                                        _preload_content=params.get('_preload_content', True),
1352                                        _request_timeout=params.get('_request_timeout'),
1353                                        collection_formats=collection_formats)
1354
1355    def list_configurations(self, account_id, **kwargs):
1356        """
1357        Get Connect Configuration Information
1358        Retrieves all the DocuSign Custom Connect definitions for the specified account.  ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce.
1359        This method makes a synchronous HTTP request by default. To make an
1360        asynchronous HTTP request, please define a `callback` function
1361        to be invoked when receiving the response.
1362        >>> def callback_function(response):
1363        >>>     pprint(response)
1364        >>>
1365        >>> thread = api.list_configurations(account_id, callback=callback_function)
1366
1367        :param callback function: The callback function
1368            for asynchronous request. (optional)
1369        :param str account_id: The external account number (int) or account ID Guid. (required)
1370        :return: ConnectConfigResults
1371                 If the method is called asynchronously,
1372                 returns the request thread.
1373        """
1374        kwargs['_return_http_data_only'] = True
1375        if kwargs.get('callback'):
1376            return self.list_configurations_with_http_info(account_id, **kwargs)
1377        else:
1378            (data) = self.list_configurations_with_http_info(account_id, **kwargs)
1379            return data
1380
1381    def list_configurations_with_http_info(self, account_id, **kwargs):
1382        """
1383        Get Connect Configuration Information
1384        Retrieves all the DocuSign Custom Connect definitions for the specified account.  ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce.
1385        This method makes a synchronous HTTP request by default. To make an
1386        asynchronous HTTP request, please define a `callback` function
1387        to be invoked when receiving the response.
1388        >>> def callback_function(response):
1389        >>>     pprint(response)
1390        >>>
1391        >>> thread = api.list_configurations_with_http_info(account_id, callback=callback_function)
1392
1393        :param callback function: The callback function
1394            for asynchronous request. (optional)
1395        :param str account_id: The external account number (int) or account ID Guid. (required)
1396        :return: ConnectConfigResults
1397                 If the method is called asynchronously,
1398                 returns the request thread.
1399        """
1400
1401        all_params = ['account_id']
1402        all_params.append('callback')
1403        all_params.append('_return_http_data_only')
1404        all_params.append('_preload_content')
1405        all_params.append('_request_timeout')
1406
1407        params = locals()
1408        for key, val in iteritems(params['kwargs']):
1409            if key not in all_params:
1410                raise TypeError(
1411                    "Got an unexpected keyword argument '%s'"
1412                    " to method list_configurations" % key
1413                )
1414            params[key] = val
1415        del params['kwargs']
1416        # verify the required parameter 'account_id' is set
1417        if ('account_id' not in params) or (params['account_id'] is None):
1418            raise ValueError("Missing the required parameter `account_id` when calling `list_configurations`")
1419
1420
1421        collection_formats = {}
1422
1423        resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json')
1424        path_params = {}
1425        if 'account_id' in params:
1426            path_params['accountId'] = params['account_id']
1427
1428        query_params = {}
1429
1430        header_params = {}
1431
1432        form_params = []
1433        local_var_files = {}
1434
1435        body_params = None
1436        # HTTP header `Accept`
1437        header_params['Accept'] = self.api_client.\
1438            select_header_accept(['application/json'])
1439
1440        # Authentication setting
1441        auth_settings = []
1442
1443        return self.api_client.call_api(resource_path, 'GET',
1444                                        path_params,
1445                                        query_params,
1446                                        header_params,
1447                                        body=body_params,
1448                                        post_params=form_params,
1449                                        files=local_var_files,
1450                                        response_type='ConnectConfigResults',
1451                                        auth_settings=auth_settings,
1452                                        callback=params.get('callback'),
1453                                        _return_http_data_only=params.get('_return_http_data_only'),
1454                                        _preload_content=params.get('_preload_content', True),
1455                                        _request_timeout=params.get('_request_timeout'),
1456                                        collection_formats=collection_formats)
1457
1458    def list_event_failure_logs(self, account_id, **kwargs):
1459        """
1460        Gets the Connect failure log information.
1461        Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created.
1462        This method makes a synchronous HTTP request by default. To make an
1463        asynchronous HTTP request, please define a `callback` function
1464        to be invoked when receiving the response.
1465        >>> def callback_function(response):
1466        >>>     pprint(response)
1467        >>>
1468        >>> thread = api.list_event_failure_logs(account_id, callback=callback_function)
1469
1470        :param callback function: The callback function
1471            for asynchronous request. (optional)
1472        :param str account_id: The external account number (int) or account ID Guid. (required)
1473        :param str from_date:
1474        :param str to_date:
1475        :return: ConnectLogs
1476                 If the method is called asynchronously,
1477                 returns the request thread.
1478        """
1479        kwargs['_return_http_data_only'] = True
1480        if kwargs.get('callback'):
1481            return self.list_event_failure_logs_with_http_info(account_id, **kwargs)
1482        else:
1483            (data) = self.list_event_failure_logs_with_http_info(account_id, **kwargs)
1484            return data
1485
1486    def list_event_failure_logs_with_http_info(self, account_id, **kwargs):
1487        """
1488        Gets the Connect failure log information.
1489        Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created.
1490        This method makes a synchronous HTTP request by default. To make an
1491        asynchronous HTTP request, please define a `callback` function
1492        to be invoked when receiving the response.
1493        >>> def callback_function(response):
1494        >>>     pprint(response)
1495        >>>
1496        >>> thread = api.list_event_failure_logs_with_http_info(account_id, callback=callback_function)
1497
1498        :param callback function: The callback function
1499            for asynchronous request. (optional)
1500        :param str account_id: The external account number (int) or account ID Guid. (required)
1501        :param str from_date:
1502        :param str to_date:
1503        :return: ConnectLogs
1504                 If the method is called asynchronously,
1505                 returns the request thread.
1506        """
1507
1508        all_params = ['account_id', 'from_date', 'to_date']
1509        all_params.append('callback')
1510        all_params.append('_return_http_data_only')
1511        all_params.append('_preload_content')
1512        all_params.append('_request_timeout')
1513
1514        params = locals()
1515        for key, val in iteritems(params['kwargs']):
1516            if key not in all_params:
1517                raise TypeError(
1518                    "Got an unexpected keyword argument '%s'"
1519                    " to method list_event_failure_logs" % key
1520                )
1521            params[key] = val
1522        del params['kwargs']
1523        # verify the required parameter 'account_id' is set
1524        if ('account_id' not in params) or (params['account_id'] is None):
1525            raise ValueError("Missing the required parameter `account_id` when calling `list_event_failure_logs`")
1526
1527
1528        collection_formats = {}
1529
1530        resource_path = '/v2.1/accounts/{accountId}/connect/failures'.replace('{format}', 'json')
1531        path_params = {}
1532        if 'account_id' in params:
1533            path_params['accountId'] = params['account_id']
1534
1535        query_params = {}
1536        if 'from_date' in params:
1537            query_params['from_date'] = params['from_date']
1538        if 'to_date' in params:
1539            query_params['to_date'] = params['to_date']
1540
1541        header_params = {}
1542
1543        form_params = []
1544        local_var_files = {}
1545
1546        body_params = None
1547        # HTTP header `Accept`
1548        header_params['Accept'] = self.api_client.\
1549            select_header_accept(['application/json'])
1550
1551        # Authentication setting
1552        auth_settings = []
1553
1554        return self.api_client.call_api(resource_path, 'GET',
1555                                        path_params,
1556                                        query_params,
1557                                        header_params,
1558                                        body=body_params,
1559                                        post_params=form_params,
1560                                        files=local_var_files,
1561                                        response_type='ConnectLogs',
1562                                        auth_settings=auth_settings,
1563                                        callback=params.get('callback'),
1564                                        _return_http_data_only=params.get('_return_http_data_only'),
1565                                        _preload_content=params.get('_preload_content', True),
1566                                        _request_timeout=params.get('_request_timeout'),
1567                                        collection_formats=collection_formats)
1568
1569    def list_event_logs(self, account_id, **kwargs):
1570        """
1571        Gets the Connect log.
1572        Retrieves a list of connect log entries for your account.  ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 
1573        This method makes a synchronous HTTP request by default. To make an
1574        asynchronous HTTP request, please define a `callback` function
1575        to be invoked when receiving the response.
1576        >>> def callback_function(response):
1577        >>>     pprint(response)
1578        >>>
1579        >>> thread = api.list_event_logs(account_id, callback=callback_function)
1580
1581        :param callback function: The callback function
1582            for asynchronous request. (optional)
1583        :param str account_id: The external account number (int) or account ID Guid. (required)
1584        :param str from_date:
1585        :param str to_date:
1586        :return: ConnectLogs
1587                 If the method is called asynchronously,
1588                 returns the request thread.
1589        """
1590        kwargs['_return_http_data_only'] = True
1591        if kwargs.get('callback'):
1592            return self.list_event_logs_with_http_info(account_id, **kwargs)
1593        else:
1594            (data) = self.list_event_logs_with_http_info(account_id, **kwargs)
1595            return data
1596
1597    def list_event_logs_with_http_info(self, account_id, **kwargs):
1598        """
1599        Gets the Connect log.
1600        Retrieves a list of connect log entries for your account.  ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 
1601        This method makes a synchronous HTTP request by default. To make an
1602        asynchronous HTTP request, please define a `callback` function
1603        to be invoked when receiving the response.
1604        >>> def callback_function(response):
1605        >>>     pprint(response)
1606        >>>
1607        >>> thread = api.list_event_logs_with_http_info(account_id, callback=callback_function)
1608
1609        :param callback function: The callback function
1610            for asynchronous request. (optional)
1611        :param str account_id: The external account number (int) or account ID Guid. (required)
1612        :param str from_date:
1613        :param str to_date:
1614        :return: ConnectLogs
1615                 If the method is called asynchronously,
1616                 returns the request thread.
1617        """
1618
1619        all_params = ['account_id', 'from_date', 'to_date']
1620        all_params.append('callback')
1621        all_params.append('_return_http_data_only')
1622        all_params.append('_preload_content')
1623        all_params.append('_request_timeout')
1624
1625        params = locals()
1626        for key, val in iteritems(params['kwargs']):
1627            if key not in all_params:
1628                raise TypeError(
1629                    "Got an unexpected keyword argument '%s'"
1630                    " to method list_event_logs" % key
1631                )
1632            params[key] = val
1633        del params['kwargs']
1634        # verify the required parameter 'account_id' is set
1635        if ('account_id' not in params) or (params['account_id'] is None):
1636            raise ValueError("Missing the required parameter `account_id` when calling `list_event_logs`")
1637
1638
1639        collection_formats = {}
1640
1641        resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json')
1642        path_params = {}
1643        if 'account_id' in params:
1644            path_params['accountId'] = params['account_id']
1645
1646        query_params = {}
1647        if 'from_date' in params:
1648            query_params['from_date'] = params['from_date']
1649        if 'to_date' in params:
1650            query_params['to_date'] = params['to_date']
1651
1652        header_params = {}
1653
1654        form_params = []
1655        local_var_files = {}
1656
1657        body_params = None
1658        # HTTP header `Accept`
1659        header_params['Accept'] = self.api_client.\
1660            select_header_accept(['application/json'])
1661
1662        # Authentication setting
1663        auth_settings = []
1664
1665        return self.api_client.call_api(resource_path, 'GET',
1666                                        path_params,
1667                                        query_params,
1668                                        header_params,
1669                                        body=body_params,
1670                                        post_params=form_params,
1671                                        files=local_var_files,
1672                                        response_type='ConnectLogs',
1673                                        auth_settings=auth_settings,
1674                                        callback=params.get('callback'),
1675                                        _return_http_data_only=params.get('_return_http_data_only'),
1676                                        _preload_content=params.get('_preload_content', True),
1677                                        _request_timeout=params.get('_request_timeout'),
1678                                        collection_formats=collection_formats)
1679
1680    def list_mobile_notifiers(self, account_id, **kwargs):
1681        """
1682        Reserved
1683        Reserved:
1684        This method makes a synchronous HTTP request by default. To make an
1685        asynchronous HTTP request, please define a `callback` function
1686        to be invoked when receiving the response.
1687        >>> def callback_function(response):
1688        >>>     pprint(response)
1689        >>>
1690        >>> thread = api.list_mobile_notifiers(account_id, callback=callback_function)
1691
1692        :param callback function: The callback function
1693            for asynchronous request. (optional)
1694        :param str account_id: The external account number (int) or account ID Guid. (required)
1695        :return: MobileNotifierConfigurationInformation
1696                 If the method is called asynchronously,
1697                 returns the request thread.
1698        """
1699        kwargs['_return_http_data_only'] = True
1700        if kwargs.get('callback'):
1701            return self.list_mobile_notifiers_with_http_info(account_id, **kwargs)
1702        else:
1703            (data) = self.list_mobile_notifiers_with_http_info(account_id, **kwargs)
1704            return data
1705
1706    def list_mobile_notifiers_with_http_info(self, account_id, **kwargs):
1707        """
1708        Reserved
1709        Reserved:
1710        This method makes a synchronous HTTP request by default. To make an
1711        asynchronous HTTP request, please define a `callback` function
1712        to be invoked when receiving the response.
1713        >>> def callback_function(response):
1714        >>>     pprint(response)
1715        >>>
1716        >>> thread = api.list_mobile_notifiers_with_http_info(account_id, callback=callback_function)
1717
1718        :param callback function: The callback function
1719            for asynchronous request. (optional)
1720        :param str account_id: The external account number (int) or account ID Guid. (required)
1721        :return: MobileNotifierConfigurationInformation
1722                 If the method is called asynchronously,
1723                 returns the request thread.
1724        """
1725
1726        all_params = ['account_id']
1727        all_params.append('callback')
1728        all_params.append('_return_http_data_only')
1729        all_params.append('_preload_content')
1730        all_params.append('_request_timeout')
1731
1732        params = locals()
1733        for key, val in iteritems(params['kwargs']):
1734            if key not in all_params:
1735                raise TypeError(
1736                    "Got an unexpected keyword argument '%s'"
1737                    " to method list_mobile_notifiers" % key
1738                )
1739            params[key] = val
1740        del params['kwargs']
1741        # verify the required parameter 'account_id' is set
1742        if ('account_id' not in params) or (params['account_id'] is None):
1743            raise ValueError("Missing the required parameter `account_id` when calling `list_mobile_notifiers`")
1744
1745
1746        collection_formats = {}
1747
1748        resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json')
1749        path_params = {}
1750        if 'account_id' in params:
1751            path_params['accountId'] = params['account_id']
1752
1753        query_params = {}
1754
1755        header_params = {}
1756
1757        form_params = []
1758        local_var_files = {}
1759
1760        body_params = None
1761        # HTTP header `Accept`
1762        header_params['Accept'] = self.api_client.\
1763            select_header_accept(['application/json'])
1764
1765        # Authentication setting
1766        auth_settings = []
1767
1768        return self.api_client.call_api(resource_path, 'GET',
1769                                        path_params,
1770                                        query_params,
1771                                        header_params,
1772                                        body=body_params,
1773                                        post_params=form_params,
1774                                        files=local_var_files,
1775                                        response_type='MobileNotifierConfigurationInformation',
1776                                        auth_settings=auth_settings,
1777                                        callback=params.get('callback'),
1778                                        _return_http_data_only=params.get('_return_http_data_only'),
1779                                        _preload_content=params.get('_preload_content', True),
1780                                        _request_timeout=params.get('_request_timeout'),
1781                                        collection_formats=collection_formats)
1782
1783    def list_users(self, account_id, connect_id, **kwargs):
1784        """
1785        Returns users from the configured Connect service.
1786        Returns users from the configured Connect service.
1787        This method makes a synchronous HTTP request by default. To make an
1788        asynchronous HTTP request, please define a `callback` function
1789        to be invoked when receiving the response.
1790        >>> def callback_function(response):
1791        >>>     pprint(response)
1792        >>>
1793        >>> thread = api.list_users(account_id, connect_id, callback=callback_function)
1794
1795        :param callback function: The callback function
1796            for asynchronous request. (optional)
1797        :param str account_id: The external account number (int) or account ID Guid. (required)
1798        :param str connect_id: The ID of the custom Connect configuration being accessed. (required)
1799        :param str count:
1800        :param str email_substring:
1801        :param str list_included_users:
1802        :param str start_position:
1803        :param str status:
1804        :param str user_name_substring:
1805        :return: IntegratedUserInfoList
1806                 If the method is called asynchronously,
1807                 returns the request thread.
1808        """
1809        kwargs['_return_http_data_only'] = True
1810        if kwargs.get('callback'):
1811            return self.list_users_with_http_info(account_id, connect_id, **kwargs)
1812        else:
1813            (data) = self.list_users_with_http_info(account_id, connect_id, **kwargs)
1814            return data
1815
1816    def list_users_with_http_info(self, account_id, connect_id, **kwargs):
1817        """
1818        Returns users from the configured Connect service.
1819        Returns users from the configured Connect service.
1820        This method makes a synchronous HTTP request by default. To make an
1821        asynchronous HTTP request, please define a `callback` function
1822        to be invoked when receiving the response.
1823        >>> def callback_function(response):
1824        >>>     pprint(response)
1825        >>>
1826        >>> thread = api.list_users_with_http_info(account_id, connect_id, callback=callback_function)
1827
1828        :param callback function: The callback function
1829            for asynchronous request. (optional)
1830        :param str account_id: The external account number (int) or account ID Guid. (required)
1831        :param str connect_id: The ID of the custom Connect configuration being accessed. (required)
1832        :param str count:
1833        :param str email_substring:
1834        :param str list_included_users:
1835        :param str start_position:
1836        :param str status:
1837        :param str user_name_substring:
1838        :return: IntegratedUserInfoList
1839                 If the method is called asynchronously,
1840                 returns the request thread.
1841        """
1842
1843        all_params = ['account_id', 'connect_id', 'count', 'email_substring', 'list_included_users', 'start_position', 'status', 'user_name_substring']
1844        all_params.append('callback')
1845        all_params.append('_return_http_data_only')
1846        all_params.append('_preload_content')
1847        all_params.append('_request_timeout')
1848
1849        params = locals()
1850        for key, val in iteritems(params['kwargs']):
1851            if key not in all_params:
1852                raise TypeError(
1853                    "Got an unexpected keyword argument '%s'"
1854                    " to method list_users" % key
1855                )
1856            params[key] = val
1857        del params['kwargs']
1858        # verify the required parameter 'account_id' is set
1859        if ('account_id' not in params) or (params['account_id'] is None):
1860            raise ValueError("Missing the required parameter `account_id` when calling `list_users`")
1861        # verify the required parameter 'connect_id' is set
1862        if ('connect_id' not in params) or (params['connect_id'] is None):
1863            raise ValueError("Missing the required parameter `connect_id` when calling `list_users`")
1864
1865
1866        collection_formats = {}
1867
1868        resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/users'.replace('{format}', 'json')
1869        path_params = {}
1870        if 'account_id' in params:
1871            path_params['accountId'] = params['account_id']
1872        if 'connect_id' in params:
1873            path_params['connectId'] = params['connect_id']
1874
1875        query_params = {}
1876        if 'count' in params:
1877            query_params['count'] = params['count']
1878        if 'email_substring' in params:
1879            query_params['email_substring'] = params['email_substring']
1880        if 'list_included_users' in params:
1881            query_params['list_included_users'] = params['list_included_users']
1882        if 'start_position' in params:
1883            query_params['start_position'] = params['start_position']
1884        if 'status' in params:
1885            query_params['status'] = params['status']
1886        if 'user_name_substring' in params:
1887            query_params['user_name_substring'] = params['user_name_substring']
1888
1889        header_params = {}
1890
1891        form_params = []
1892        local_var_files = {}
1893
1894        body_params = None
1895        # HTTP header `Accept`
1896        header_params['Accept'] = self.api_client.\
1897            select_header_accept(['application/json'])
1898
1899        # Authentication setting
1900        auth_settings = []
1901
1902        return self.api_client.call_api(resource_path, 'GET',
1903                                        path_params,
1904                                        query_params,
1905                                        header_params,
1906                                        body=body_params,
1907                                        post_params=form_params,
1908                                        files=local_var_files,
1909                                        response_type='IntegratedUserInfoList',
1910                                        auth_settings=auth_settings,
1911                                        callback=params.get('callback'),
1912                                        _return_http_data_only=params.get('_return_http_data_only'),
1913                                        _preload_content=params.get('_preload_content', True),
1914                                        _request_timeout=params.get('_request_timeout'),
1915                                        collection_formats=collection_formats)
1916
1917    def retry_event_for_envelope(self, account_id, envelope_id, **kwargs):
1918        """
1919        Republishes Connect information for the specified envelope.
1920        Republishes Connect information for the specified envelope.
1921        This method makes a synchronous HTTP request by default. To make an
1922        asynchronous HTTP request, please define a `callback` function
1923        to be invoked when receiving the response.
1924        >>> def callback_function(response):
1925        >>>     pprint(response)
1926        >>>
1927        >>> thread = api.retry_event_for_envelope(account_id, envelope_id, callback=callback_function)
1928
1929        :param callback function: The callback function
1930            for asynchronous request. (optional)
1931        :param str account_id: The external account number (int) or account ID Guid. (required)
1932        :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
1933        :return: ConnectFailureResults
1934                 If the method is called asynchronously,
1935                 returns the request thread.
1936        """
1937        kwargs['_return_http_data_only'] = True
1938        if kwargs.get('callback'):
1939            return self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs)
1940        else:
1941            (data) = self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs)
1942            return data
1943
1944    def retry_event_for_envelope_with_http_info(self, account_id, envelope_id, **kwargs):
1945        """
1946        Republishes Connect information for the specified envelope.
1947        Republishes Connect information for the specified envelope.
1948        This method makes a synchronous HTTP request by default. To make an
1949        asynchronous HTTP request, please define a `callback` function
1950        to be invoked when receiving the response.
1951        >>> def callback_function(response):
1952        >>>     pprint(response)
1953        >>>
1954        >>> thread = api.retry_event_for_envelope_with_http_info(account_id, envelope_id, callback=callback_function)
1955
1956        :param callback function: The callback function
1957            for asynchronous request. (optional)
1958        :param str account_id: The external account number (int) or account ID Guid. (required)
1959        :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
1960        :return: ConnectFailureResults
1961                 If the method is called asynchronously,
1962                 returns the request thread.
1963        """
1964
1965        all_params = ['account_id', 'envelope_id']
1966        all_params.append('callback')
1967        all_params.append('_return_http_data_only')
1968        all_params.append('_preload_content')
1969        all_params.append('_request_timeout')
1970
1971        params = locals()
1972        for key, val in iteritems(params['kwargs']):
1973            if key not in all_params:
1974                raise TypeError(
1975                    "Got an unexpected keyword argument '%s'"
1976                    " to method retry_event_for_envelope" % key
1977                )
1978            params[key] = val
1979        del params['kwargs']
1980        # verify the required parameter 'account_id' is set
1981        if ('account_id' not in params) or (params['account_id'] is None):
1982            raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelope`")
1983        # verify the required parameter 'envelope_id' is set
1984        if ('envelope_id' not in params) or (params['envelope_id'] is None):
1985            raise ValueError("Missing the required parameter `envelope_id` when calling `retry_event_for_envelope`")
1986
1987
1988        collection_formats = {}
1989
1990        resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/{envelopeId}/retry_queue'.replace('{format}', 'json')
1991        path_params = {}
1992        if 'account_id' in params:
1993            path_params['accountId'] = params['account_id']
1994        if 'envelope_id' in params:
1995            path_params['envelopeId'] = params['envelope_id']
1996
1997        query_params = {}
1998
1999        header_params = {}
2000
2001        form_params = []
2002        local_var_files = {}
2003
2004        body_params = None
2005        # HTTP header `Accept`
2006        header_params['Accept'] = self.api_client.\
2007            select_header_accept(['application/json'])
2008
2009        # Authentication setting
2010        auth_settings = []
2011
2012        return self.api_client.call_api(resource_path, 'PUT',
2013                                        path_params,
2014                                        query_params,
2015                                        header_params,
2016                                        body=body_params,
2017                                        post_params=form_params,
2018                                        files=local_var_files,
2019                                        response_type='ConnectFailureResults',
2020                                        auth_settings=auth_settings,
2021                                        callback=params.get('callback'),
2022                                        _return_http_data_only=params.get('_return_http_data_only'),
2023                                        _preload_content=params.get('_preload_content', True),
2024                                        _request_timeout=params.get('_request_timeout'),
2025                                        collection_formats=collection_formats)
2026
2027    def retry_event_for_envelopes(self, account_id, **kwargs):
2028        """
2029        Republishes Connect information for multiple envelopes.
2030        Republishes Connect information for the  specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log.
2031        This method makes a synchronous HTTP request by default. To make an
2032        asynchronous HTTP request, please define a `callback` function
2033        to be invoked when receiving the response.
2034        >>> def callback_function(response):
2035        >>>     pprint(response)
2036        >>>
2037        >>> thread = api.retry_event_for_envelopes(account_id, callback=callback_function)
2038
2039        :param callback function: The callback function
2040            for asynchronous request. (optional)
2041        :param str account_id: The external account number (int) or account ID Guid. (required)
2042        :param ConnectFailureFilter connect_failure_filter:
2043        :return: ConnectFailureResults
2044                 If the method is called asynchronously,
2045                 returns the request thread.
2046        """
2047        kwargs['_return_http_data_only'] = True
2048        if kwargs.get('callback'):
2049            return self.retry_event_for_envelopes_with_http_info(account_id, **kwargs)
2050        else:
2051            (data) = self.retry_event_for_envelopes_with_http_info(account_id, **kwargs)
2052            return data
2053
2054    def retry_event_for_envelopes_with_http_info(self, account_id, **kwargs):
2055        """
2056        Republishes Connect information for multiple envelopes.
2057        Republishes Connect information for the  specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log.
2058        This method makes a synchronous HTTP request by default. To make an
2059        asynchronous HTTP request, please define a `callback` function
2060        to be invoked when receiving the response.
2061        >>> def callback_function(response):
2062        >>>     pprint(response)
2063        >>>
2064        >>> thread = api.retry_event_for_envelopes_with_http_info(account_id, callback=callback_function)
2065
2066        :param callback function: The callback function
2067            for asynchronous request. (optional)
2068        :param str account_id: The external account number (int) or account ID Guid. (required)
2069        :param ConnectFailureFilter connect_failure_filter:
2070        :return: ConnectFailureResults
2071                 If the method is called asynchronously,
2072                 returns the request thread.
2073        """
2074
2075        all_params = ['account_id', 'connect_failure_filter']
2076        all_params.append('callback')
2077        all_params.append('_return_http_data_only')
2078        all_params.append('_preload_content')
2079        all_params.append('_request_timeout')
2080
2081        params = locals()
2082        for key, val in iteritems(params['kwargs']):
2083            if key not in all_params:
2084                raise TypeError(
2085                    "Got an unexpected keyword argument '%s'"
2086                    " to method retry_event_for_envelopes" % key
2087                )
2088            params[key] = val
2089        del params['kwargs']
2090        # verify the required parameter 'account_id' is set
2091        if ('account_id' not in params) or (params['account_id'] is None):
2092            raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelopes`")
2093
2094
2095        collection_formats = {}
2096
2097        resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/retry_queue'.replace('{format}', 'json')
2098        path_params = {}
2099        if 'account_id' in params:
2100            path_params['accountId'] = params['account_id']
2101
2102        query_params = {}
2103
2104        header_params = {}
2105
2106        form_params = []
2107        local_var_files = {}
2108
2109        body_params = None
2110        if 'connect_failure_filter' in params:
2111            body_params = params['connect_failure_filter']
2112        # HTTP header `Accept`
2113        header_params['Accept'] = self.api_client.\
2114            select_header_accept(['application/json'])
2115
2116        # Authentication setting
2117        auth_settings = []
2118
2119        return self.api_client.call_api(resource_path, 'PUT',
2120                                        path_params,
2121                                        query_params,
2122                                        header_params,
2123                                        body=body_params,
2124                                        post_params=form_params,
2125                                        files=local_var_files,
2126                                        response_type='ConnectFailureResults',
2127                                        auth_settings=auth_settings,
2128                                        callback=params.get('callback'),
2129                                        _return_http_data_only=params.get('_return_http_data_only'),
2130                                        _preload_content=params.get('_preload_content', True),
2131                                        _request_timeout=params.get('_request_timeout'),
2132                                        collection_formats=collection_formats)
2133
2134    def update_configuration(self, account_id, **kwargs):
2135        """
2136        Updates a specified Connect configuration.
2137        Updates the specified DocuSign Connect configuration in your account.  ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce.
2138        This method makes a synchronous HTTP request by default. To make an
2139        asynchronous HTTP request, please define a `callback` function
2140        to be invoked when receiving the response.
2141        >>> def callback_function(response):
2142        >>>     pprint(response)
2143        >>>
2144        >>> thread = api.update_configuration(account_id, callback=callback_function)
2145
2146        :param callback function: The callback function
2147            for asynchronous request. (optional)
2148        :param str account_id: The external account number (int) or account ID Guid. (required)
2149        :param ConnectCustomConfiguration connect_custom_configuration:
2150        :return: ConnectCustomConfiguration
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.update_configuration_with_http_info(account_id, **kwargs)
2157        else:
2158            (data) = self.update_configuration_with_http_info(account_id, **kwargs)
2159            return data
2160
2161    def update_configuration_with_http_info(self, account_id, **kwargs):
2162        """
2163        Updates a specified Connect configuration.
2164        Updates the specified DocuSign Connect configuration in your account.  ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce.
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.update_configuration_with_http_info(account_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 ConnectCustomConfiguration connect_custom_configuration:
2177        :return: ConnectCustomConfiguration
2178                 If the method is called asynchronously,
2179                 returns the request thread.
2180        """
2181
2182        all_params = ['account_id', 'connect_custom_configuration']
2183        all_params.append('callback')
2184        all_params.append('_return_http_data_only')
2185        all_params.append('_preload_content')
2186        all_params.append('_request_timeout')
2187
2188        params = locals()
2189        for key, val in iteritems(params['kwargs']):
2190            if key not in all_params:
2191                raise TypeError(
2192                    "Got an unexpected keyword argument '%s'"
2193                    " to method update_configuration" % key
2194                )
2195            params[key] = val
2196        del params['kwargs']
2197        # verify the required parameter 'account_id' is set
2198        if ('account_id' not in params) or (params['account_id'] is None):
2199            raise ValueError("Missing the required parameter `account_id` when calling `update_configuration`")
2200
2201
2202        collection_formats = {}
2203
2204        resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json')
2205        path_params = {}
2206        if 'account_id' in params:
2207            path_params['accountId'] = params['account_id']
2208
2209        query_params = {}
2210
2211        header_params = {}
2212
2213        form_params = []
2214        local_var_files = {}
2215
2216        body_params = None
2217        if 'connect_custom_configuration' in params:
2218            body_params = params['connect_custom_configuration']
2219        # HTTP header `Accept`
2220        header_params['Accept'] = self.api_client.\
2221            select_header_accept(['application/json'])
2222
2223        # Authentication setting
2224        auth_settings = []
2225
2226        return self.api_client.call_api(resource_path, 'PUT',
2227                                        path_params,
2228                                        query_params,
2229                                        header_params,
2230                                        body=body_params,
2231                                        post_params=form_params,
2232                                        files=local_var_files,
2233                                        response_type='ConnectCustomConfiguration',
2234                                        auth_settings=auth_settings,
2235                                        callback=params.get('callback'),
2236                                        _return_http_data_only=params.get('_return_http_data_only'),
2237                                        _preload_content=params.get('_preload_content', True),
2238                                        _request_timeout=params.get('_request_timeout'),
2239                                        collection_formats=collection_formats)
2240
2241    def update_connect_o_auth_config(self, account_id, **kwargs):
2242        """
2243        Updates the existing Connect OAuth Config for the account.
2244        This method makes a synchronous HTTP request by default. To make an
2245        asynchronous HTTP request, please define a `callback` function
2246        to be invoked when receiving the response.
2247        >>> def callback_function(response):
2248        >>>     pprint(response)
2249        >>>
2250        >>> thread = api.update_connect_o_auth_config(account_id, callback=callback_function)
2251
2252        :param callback function: The callback function
2253            for asynchronous request. (optional)
2254        :param str account_id: The external account number (int) or account ID Guid. (required)
2255        :param ConnectOAuthConfig connect_o_auth_config:
2256        :return: ConnectOAuthConfig
2257                 If the method is called asynchronously,
2258                 returns the request thread.
2259        """
2260        kwargs['_return_http_data_only'] = True
2261        if kwargs.get('callback'):
2262            return self.update_connect_o_auth_config_with_http_info(account_id, **kwargs)
2263        else:
2264            (data) = self.update_connect_o_auth_config_with_http_info(account_id, **kwargs)
2265            return data
2266
2267    def update_connect_o_auth_config_with_http_info(self, account_id, **kwargs):
2268        """
2269        Updates the existing Connect OAuth Config for the account.
2270        This method makes a synchronous HTTP request by default. To make an
2271        asynchronous HTTP request, please define a `callback` function
2272        to be invoked when receiving the response.
2273        >>> def callback_function(response):
2274        >>>     pprint(response)
2275        >>>
2276        >>> thread = api.update_connect_o_auth_config_with_http_info(account_id, callback=callback_function)
2277
2278        :param callback function: The callback function
2279            for asynchronous request. (optional)
2280        :param str account_id: The external account number (int) or account ID Guid. (required)
2281        :param ConnectOAuthConfig connect_o_auth_config:
2282        :return: ConnectOAuthConfig
2283                 If the method is called asynchronously,
2284                 returns the request thread.
2285        """
2286
2287        all_params = ['account_id', 'connect_o_auth_config']
2288        all_params.append('callback')
2289        all_params.append('_return_http_data_only')
2290        all_params.append('_preload_content')
2291        all_params.append('_request_timeout')
2292
2293        params = locals()
2294        for key, val in iteritems(params['kwargs']):
2295            if key not in all_params:
2296                raise TypeError(
2297                    "Got an unexpected keyword argument '%s'"
2298                    " to method update_connect_o_auth_config" % key
2299                )
2300            params[key] = val
2301        del params['kwargs']
2302        # verify the required parameter 'account_id' is set
2303        if ('account_id' not in params) or (params['account_id'] is None):
2304            raise ValueError("Missing the required parameter `account_id` when calling `update_connect_o_auth_config`")
2305
2306
2307        collection_formats = {}
2308
2309        resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json')
2310        path_params = {}
2311        if 'account_id' in params:
2312            path_params['accountId'] = params['account_id']
2313
2314        query_params = {}
2315
2316        header_params = {}
2317
2318        form_params = []
2319        local_var_files = {}
2320
2321        body_params = None
2322        if 'connect_o_auth_config' in params:
2323            body_params = params['connect_o_auth_config']
2324        # HTTP header `Accept`
2325        header_params['Accept'] = self.api_client.\
2326            select_header_accept(['application/json'])
2327
2328        # Authentication setting
2329        auth_settings = []
2330
2331        return self.api_client.call_api(resource_path, 'PUT',
2332                                        path_params,
2333                                        query_params,
2334                                        header_params,
2335                                        body=body_params,
2336                                        post_params=form_params,
2337                                        files=local_var_files,
2338                                        response_type='ConnectOAuthConfig',
2339                                        auth_settings=auth_settings,
2340                                        callback=params.get('callback'),
2341                                        _return_http_data_only=params.get('_return_http_data_only'),
2342                                        _preload_content=params.get('_preload_content', True),
2343                                        _request_timeout=params.get('_request_timeout'),
2344                                        collection_formats=collection_formats)
2345
2346    def update_mobile_notifiers(self, account_id, **kwargs):
2347        """
2348        Reserved
2349        Reserved:
2350        This method makes a synchronous HTTP request by default. To make an
2351        asynchronous HTTP request, please define a `callback` function
2352        to be invoked when receiving the response.
2353        >>> def callback_function(response):
2354        >>>     pprint(response)
2355        >>>
2356        >>> thread = api.update_mobile_notifiers(account_id, callback=callback_function)
2357
2358        :param callback function: The callback function
2359            for asynchronous request. (optional)
2360        :param str account_id: The external account number (int) or account ID Guid. (required)
2361        :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information:
2362        :return: MobileNotifierConfigurationInformation
2363                 If the method is called asynchronously,
2364                 returns the request thread.
2365        """
2366        kwargs['_return_http_data_only'] = True
2367        if kwargs.get('callback'):
2368            return self.update_mobile_notifiers_with_http_info(account_id, **kwargs)
2369        else:
2370            (data) = self.update_mobile_notifiers_with_http_info(account_id, **kwargs)
2371            return data
2372
2373    def update_mobile_notifiers_with_http_info(self, account_id, **kwargs):
2374        """
2375        Reserved
2376        Reserved:
2377        This method makes a synchronous HTTP request by default. To make an
2378        asynchronous HTTP request, please define a `callback` function
2379        to be invoked when receiving the response.
2380        >>> def callback_function(response):
2381        >>>     pprint(response)
2382        >>>
2383        >>> thread = api.update_mobile_notifiers_with_http_info(account_id, callback=callback_function)
2384
2385        :param callback function: The callback function
2386            for asynchronous request. (optional)
2387        :param str account_id: The external account number (int) or account ID Guid. (required)
2388        :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information:
2389        :return: MobileNotifierConfigurationInformation
2390                 If the method is called asynchronously,
2391                 returns the request thread.
2392        """
2393
2394        all_params = ['account_id', 'mobile_notifier_configuration_information']
2395        all_params.append('callback')
2396        all_params.append('_return_http_data_only')
2397        all_params.append('_preload_content')
2398        all_params.append('_request_timeout')
2399
2400        params = locals()
2401        for key, val in iteritems(params['kwargs']):
2402            if key not in all_params:
2403                raise TypeError(
2404                    "Got an unexpected keyword argument '%s'"
2405                    " to method update_mobile_notifiers" % key
2406                )
2407            params[key] = val
2408        del params['kwargs']
2409        # verify the required parameter 'account_id' is set
2410        if ('account_id' not in params) or (params['account_id'] is None):
2411            raise ValueError("Missing the required parameter `account_id` when calling `update_mobile_notifiers`")
2412
2413
2414        collection_formats = {}
2415
2416        resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json')
2417        path_params = {}
2418        if 'account_id' in params:
2419            path_params['accountId'] = params['account_id']
2420
2421        query_params = {}
2422
2423        header_params = {}
2424
2425        form_params = []
2426        local_var_files = {}
2427
2428        body_params = None
2429        if 'mobile_notifier_configuration_information' in params:
2430            body_params = params['mobile_notifier_configuration_information']
2431        # HTTP header `Accept`
2432        header_params['Accept'] = self.api_client.\
2433            select_header_accept(['application/json'])
2434
2435        # Authentication setting
2436        auth_settings = []
2437
2438        return self.api_client.call_api(resource_path, 'PUT',
2439                                        path_params,
2440                                        query_params,
2441                                        header_params,
2442                                        body=body_params,
2443                                        post_params=form_params,
2444                                        files=local_var_files,
2445                                        response_type='MobileNotifierConfigurationInformation',
2446                                        auth_settings=auth_settings,
2447                                        callback=params.get('callback'),
2448                                        _return_http_data_only=params.get('_return_http_data_only'),
2449                                        _preload_content=params.get('_preload_content', True),
2450                                        _request_timeout=params.get('_request_timeout'),
2451                                        collection_formats=collection_formats)